@vyr/three 0.0.33 → 0.0.35

package/src/interpreter/GeoMapInterpreter.ts

@@ -1,28 +1,27 @@
 import { Material, Mesh, Object3D, Vector2 as _V2, BufferGeometry } from "three";
-import { Asset, AsyncTask, Category, Data, DatasetDescriptor, Descriptor, Generate, Graphics, Interpreter, JsonAsset, observer, PrefabeDescriptor, PrefabInstanceDescriptor, Queue, InteractionDescriptor, InteractionNode, Unit, Vector2 } from "@vyr/engine";
-import { ExtrudeGeometryDescriptor, GeoMapDescriptor, GeometryDescriptor, HTMLConvertDescriptor, PlaneGeometryDescriptor, TubeGeometryDescriptor } from '../descriptor'
+import { Asset, AsyncTask, Suffix, Data, Store, Descriptor, Graphics, Interpreter, JsonAsset, observer, HTML, Unit, Vector2 } from "@vyr/engine";
+import { ExtrudeGeometry, GeoMap, Geometry, HTMLConvert, PlaneGeometry, TubeGeometry } from '../descriptor'
 import { NodeInterpreter, PickupNode } from "./NodeInterpreter";
 import { material, diaposeObject3D, collectionPickupResult } from "../utils";
 import { NodeActor } from "../actor";
-import { executePreset, interactionPreset } from "../preset";
 
 interface GeoFeature<T extends BufferGeometry = BufferGeometry> {
     url: string
-    descriptor: GeometryDescriptor
+    descriptor: Geometry
     interpreter: Interpreter
-    dataset: string
+    store: string
     mesh: Mesh<T>
 }
 
-type GeometryFactory<T extends GeometryDescriptor = GeometryDescriptor> = (url: string, dataset: string, feature: JsonAsset, offset: Vector2) => T
+type GeometryFactory<T extends Geometry = Geometry> = (url: string, store: string, feature: JsonAsset, offset: Vector2) => T
 
-const tubeFactory: GeometryFactory = (url: string, dataset: string, feature: JsonAsset, offset: Vector2) => {
-    const descriptor = new TubeGeometryDescriptor({ name: feature.properties.adcode, track: dataset, offset, radius: 0.05, tubularSegments: 1000 })
+const tubeFactory: GeometryFactory = (url: string, store: string, feature: JsonAsset, offset: Vector2) => {
+    const descriptor = new TubeGeometry({ name: feature.properties.adcode, track: store, offset, radius: 0.05, tubularSegments: 1000 })
     Asset.set(url, descriptor)
 
-    let datasetDescriptor = Asset.get<DatasetDescriptor>(dataset)
-    if (datasetDescriptor === null) {
-        datasetDescriptor = new DatasetDescriptor({ name: feature.properties.adcode })
+    let storeDescriptor = Asset.get<Store>(store)
+    if (storeDescriptor === null) {
+        storeDescriptor = new Store({ name: feature.properties.adcode })
         let data
         if (feature.geometry.type === 'MultiPolygon') {
             data = feature.geometry.coordinates[0][0]
@@ -31,47 +30,46 @@ const tubeFactory: GeometryFactory = (url: string, dataset: string, feature: Jso
         } else {
             data = []
         }
-        datasetDescriptor.setData(data)
-        Asset.set(dataset, datasetDescriptor)
+        storeDescriptor.data = data
+        Asset.set(store, storeDescriptor)
     }
 
     return descriptor
 }
 
-const shadowFactory: GeometryFactory = (url: string, dataset: string, feature: JsonAsset, offset: Vector2) => {
-    const descriptor = new PlaneGeometryDescriptor({ name: feature.properties.adcode, width: 100, height: 100 })
+const shadowFactory: GeometryFactory = (url: string, store: string, feature: JsonAsset, offset: Vector2) => {
+    const descriptor = new PlaneGeometry({ name: feature.properties.adcode, width: 100, height: 100 })
     Asset.set(url, descriptor)
 
     return descriptor
 }
 
-const extrudeFactory: GeometryFactory = (url: string, dataset: string, feature: JsonAsset, offset: Vector2) => {
-    const descriptor = new ExtrudeGeometryDescriptor({ name: feature.properties.adcode, shapes: dataset, offset, flattenUVsToPlane: true })
+const extrudeFactory: GeometryFactory = (url: string, store: string, feature: JsonAsset, offset: Vector2) => {
+    const descriptor = new ExtrudeGeometry({ name: feature.properties.adcode, shapes: store, offset, flattenUVsToPlane: true })
     Asset.set(url, descriptor)
 
-    let datasetDescriptor = Asset.get<DatasetDescriptor>(dataset)
-    if (datasetDescriptor === null) {
-        datasetDescriptor = new DatasetDescriptor({ name: feature.properties.adcode })
+    let storeDescriptor = Asset.get<Store>(store)
+    if (storeDescriptor === null) {
+        storeDescriptor = new Store({ name: feature.properties.adcode })
         let data
         if (feature.geometry.type === 'MultiPolygon') {
             data = feature.geometry.coordinates
         } else {
             data = []
         }
-        datasetDescriptor.setData(data)
-        Asset.set(dataset, datasetDescriptor)
+        storeDescriptor.data = data
+        Asset.set(store, storeDescriptor)
     }
 
     return descriptor
 }
 
-class GeoMapInterpreter extends NodeInterpreter {
-    static type = GeoMapDescriptor.type
+export class GeoMapInterpreter extends NodeInterpreter {
+    static type = GeoMap.type
     private _task: AsyncTask | null = null
     readonly wrapper = new Object3D()
     readonly features: GeoFeature[] = []
-    readonly labels: HTMLConvertDescriptor[] = []
-    readonly interactions: InteractionDescriptor[] = []
+    readonly labels: HTMLConvert[] = []
 
     protected createActor(descriptor: Descriptor) {
         const actor = new NodeActor(new Object3D())
@@ -79,43 +77,44 @@ class GeoMapInterpreter extends NodeInterpreter {
         return actor
     }
 
-    private createLabel(descriptor: GeoMapDescriptor, prefab: PrefabeDescriptor, featureData: Data, feature: JsonAsset, offset: Vector2) {
-        const point = feature.properties.centroid ?? feature.properties.center
-        if (!point) return null
-
-        const label = new HTMLConvertDescriptor({})
-        label.position.x = point[0] + offset.x
-        label.position.y = point[1] + offset.y
-        label.position.z = 2
-        label.scale.x = 0.05
-        label.scale.y = 0.05
-        label.scale.z = 0.05
-
-        const clone = PrefabInstanceDescriptor.fromPrefab(descriptor.label, prefab)
-        label.add(clone)
-
-        const datasetUrl = Asset.createVirtualUrl(`GeoMap/dataset/label/${feature.properties.adcode}${Category.datasetSuffix}`)
-        const dataset = new DatasetDescriptor()
-        dataset.setData(featureData)
-        Asset.set(datasetUrl, dataset)
-
-        const inputs = {
-            [interactionPreset.GeoMap.drilldown.nodes.drilldown]: executePreset.GeoMap.drilldown.createExecuteInput({
-                dataset,
-                geoMap: descriptor,
-            })
-        }
-        clone.traverse(sub => {
-            sub.dataset = datasetUrl
-            sub.interactions.push({
-                uuid: Generate.uuid(),
-                type: "click",
-                url: interactionPreset.GeoMap.drilldown.url,
-                inputs,
-            })
-        })
-
-        return label
+    private createLabel(descriptor: GeoMap, prefab: HTML, featureData: Data, feature: JsonAsset, offset: Vector2) {
+        // const point = feature.properties.centroid ?? feature.properties.center
+        // if (!point) return null
+
+        // const label = new HTMLConvert({})
+        // label.position.x = point[0] + offset.x
+        // label.position.y = point[1] + offset.y
+        // label.position.z = 2
+        // label.scale.x = 0.05
+        // label.scale.y = 0.05
+        // label.scale.z = 0.05
+
+        // const clone = HTMLInstance.fromHTML(descriptor.label, prefab)
+        // clone.traverse(child => { child.generatedBy = descriptor.uuid })
+        // label.add(clone)
+
+        // const storeUrl = Asset.createVirtualUrl(`GeoMap/store/label/${feature.properties.adcode}${Suffix.storeSuffix}`)
+        // const store = new Store()
+        // store.setData(featureData)
+        // Asset.set(storeUrl, store)
+
+        // const inputs = {
+        //     [interactionPreset.GeoMap.drilldown.nodes.drilldown]: executePreset.GeoMap.drilldown.createExecuteInput({
+        //         store,
+        //         geoMap: descriptor,
+        //     })
+        // }
+        // clone.traverse(sub => {
+        //     sub.store = storeUrl
+        //     sub.interactions.push({
+        //         uuid: Generate.uuid(),
+        //         type: "click",
+        //         url: interactionPreset.GeoMap.drilldown.url,
+        //         inputs,
+        //     })
+        // })
+
+        // return label
     }
     private _createGeoData(fullJson: JsonAsset) {
         const data: Data = {}
@@ -124,28 +123,28 @@ class GeoMapInterpreter extends NodeInterpreter {
         }
         return data
     }
-    buildLabel(descriptor: GeoMapDescriptor, fullJson: JsonAsset, offset: Vector2) {
-        const prefab = Asset.get<PrefabeDescriptor>(descriptor.label)
-        if (prefab === null) return
-        const dataset = Asset.get<DatasetDescriptor>(descriptor.dataset)
-        const data = dataset === null ? this._createGeoData(fullJson) : dataset.getData<Data>()
+    buildLabel(descriptor: GeoMap, fullJson: JsonAsset, offset: Vector2) {
+        // const prefab = Asset.get<HTML>(descriptor.label)
+        // if (prefab === null) return
+        // const store = Asset.get<Store>(descriptor.store)
+        // const data = store === null ? this._createGeoData(fullJson) : store.getData<Data>()
 
-        for (const feature of fullJson.features) {
-            const featureData = data[feature.properties.adcode]
-            const label = this.createLabel(descriptor, prefab, featureData, feature, offset)
-            if (label === null) continue
-            this.labels.push(label)
-            observer.trigger('add', { puid: this.unit.uuid, self: label.uuid })
-        }
+        // for (const feature of fullJson.features) {
+        //     const featureData = data[feature.properties.adcode]
+        //     const label = this.createLabel(descriptor, prefab, featureData, feature, offset)
+        //     if (label === null) continue
+        //     this.labels.push(label)
+        //     observer.trigger('add', { puid: this.unit.uuid, self: label.uuid })
+        // }
     }
 
     buildFeature(feature: JsonAsset, materials: Material | Material[], offset: Vector2, factory: GeometryFactory, flag: string) {
-        const geometryUrl = Asset.createVirtualUrl(`GeoMap/geometry/${flag}/${feature.properties.adcode}${Category.geometrySuffix}`)
-        const datasetUrl = Asset.createVirtualUrl(`GeoMap/dataset/${flag}/${feature.properties.adcode}${Category.datasetSuffix}`)
+        const geometryUrl = Asset.createVirtualUrl(`GeoMap/geometry/${flag}/${feature.properties.adcode}${Suffix.geometrySuffix}`)
+        const storeUrl = Asset.createVirtualUrl(`GeoMap/store/${flag}/${feature.properties.adcode}${Suffix.storeSuffix}`)
 
-        let geometry = Asset.get<GeometryDescriptor>(geometryUrl)
+        let geometry = Asset.get<Geometry>(geometryUrl)
         if (geometry === null) {
-            geometry = factory(geometryUrl, datasetUrl, feature, offset)
+            geometry = factory(geometryUrl, storeUrl, feature, offset)
         }
         const interpreter = Graphics.createInterpreter(geometry, this.graphics)
         //@ts-ignore
@@ -157,32 +156,32 @@ class GeoMapInterpreter extends NodeInterpreter {
 
         this.wrapper.add(mesh)
 
-        const item: GeoFeature = { url: geometryUrl, descriptor: geometry, interpreter, dataset: datasetUrl, mesh }
+        const item: GeoFeature = { url: geometryUrl, descriptor: geometry, interpreter, store: storeUrl, mesh }
 
         return item
     }
 
     buildBorder(fullJson: JsonAsset, materials: Material | Material[], offset: Vector2, features: GeoFeature[]) {
         for (const feature of fullJson.features) {
-            const item = this.buildFeature(feature, materials, offset, tubeFactory,  'border')
+            const item = this.buildFeature(feature, materials, offset, tubeFactory, 'border')
             item.mesh.position.z = 1.22
             features.push(item)
         }
     }
 
     buildShadow(feature: JsonAsset, materials: Material | Material[], offset: Vector2) {
-        const region = this.buildFeature(feature, materials, offset, shadowFactory,  'shadow')
+        const region = this.buildFeature(feature, materials, offset, shadowFactory, 'shadow')
         this.features.push(region)
         return region
     }
 
     buildRegion(feature: JsonAsset, materials: Material | Material[], offset: Vector2) {
-        const region = this.buildFeature(feature, materials, offset, extrudeFactory,  'region')
+        const region = this.buildFeature(feature, materials, offset, extrudeFactory, 'region')
         this.features.push(region)
         return region
     }
 
-    async build(descriptor: GeoMapDescriptor) {
+    async build(descriptor: GeoMap) {
         const geojson = Asset.get<JsonAsset>(descriptor.geojsonRegion)
         if (Array.isArray(geojson.features) === false || geojson.features.length === 0) return
 
@@ -212,18 +211,18 @@ class GeoMapInterpreter extends NodeInterpreter {
         for (const feature of this.features) {
             diaposeObject3D(feature.mesh)
             Asset.unload(feature.url)
-            Asset.unload(feature.dataset)
+            Asset.unload(feature.store)
         }
         this.features.length = 0
         for (const label of this.labels) {
             observer.trigger('remove', { puid: this.unit.uuid, self: label.uuid })
-            Asset.unload(label.dataset)
+            Asset.unload(label.store)
         }
         this.labels.length = 0
         if (this._task !== null) this._task.cancel()
     }
 
-    update(descriptor: GeoMapDescriptor) {
+    update(descriptor: GeoMap) {
         super.update(descriptor)
 
         this.wrapper.layers.set(descriptor.layer)
@@ -233,21 +232,19 @@ class GeoMapInterpreter extends NodeInterpreter {
         if (descriptor.geojsonRegion) this.build(descriptor)
     }
 
-    unmount(descriptor: GeoMapDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+    unmount(descriptor: GeoMap, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
         this.clear()
-        super.unmount(descriptor,  parentInterpreter, parentDescriptor)
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
     }
 
-    free(descriptor: GeoMapDescriptor) {
+    free(descriptor: GeoMap) {
         this.clear()
         super.free(descriptor)
     }
 
-    pickup(descriptor: GeoMapDescriptor, result: PickupNode[]) {
+    pickup(descriptor: GeoMap, result: PickupNode[]) {
         if (descriptor.visible === false) return
         collectionPickupResult(this.wrapper, true, descriptor, result)
     }
 }
-NodeInterpreter.register(GeoMapInterpreter)
-
-export { GeoMapInterpreter }
+NodeInterpreter.register(GeoMapInterpreter)

package/src/interpreter/HTMLConvertInterpreter.ts

@@ -1,31 +1,29 @@
 import { Object3D } from 'three'
 import { Descriptor, Interpreter, PickupObject } from "@vyr/engine";
-import { HTMLConvertDescriptor } from "../descriptor";
+import { HTMLConvert } from "../descriptor";
 import { NodeInterpreter } from "./NodeInterpreter";
 import { HTMLConvertActor } from '../actor';
 
-class HTMLConvertInterpreter extends NodeInterpreter {
-    static type = HTMLConvertDescriptor.type
+export class HTMLConvertInterpreter extends NodeInterpreter {
+    static type = HTMLConvert.type
 
     protected createActor(descriptor: Descriptor) {
         const actor = new HTMLConvertActor(new Object3D())
         return actor
     }
 
-    unmount(descriptor: HTMLConvertDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+    unmount(descriptor: HTMLConvert, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
         const actor = this.getActor<HTMLConvertActor>(descriptor)
         actor.clear()
         super.unmount(descriptor,  parentInterpreter, parentDescriptor)
     }
 
-    free(descriptor: HTMLConvertDescriptor) {
+    free(descriptor: HTMLConvert) {
         const actor = this.getActor<HTMLConvertActor>(descriptor)
         actor.clear()
         super.free(descriptor)
     }
 
-    pickup(descriptor: HTMLConvertDescriptor, result: PickupObject[]) { }
+    pickup(descriptor: HTMLConvert, result: PickupObject[]) { }
 }
-NodeInterpreter.register(HTMLConvertInterpreter)
-
-export { HTMLConvertInterpreter }
+NodeInterpreter.register(HTMLConvertInterpreter)

package/src/interpreter/InstancedMeshInterpreter.ts

@@ -1,19 +1,19 @@
-import { Color, InstancedMesh, Matrix4, Object3D } from 'three'
-import { DatasetDescriptor } from "@vyr/engine";
-import { InstancedMeshDescriptor, InstancedSetting } from "../descriptor";
+import { Color, InstancedMesh as ThreeInstancedMesh, Matrix4, Object3D } from 'three'
+import { Store } from "@vyr/engine";
+import { InstancedMesh, InstancedData } from "../descriptor";
 import { PickupNode } from './NodeInterpreter';
 import { MeshInterpreter } from "./MeshInterpreter";
 import { NodeActor } from '../actor';
 import { material, geometry, collectionPickupResult } from '../utils';
 
-class InstancedMeshInterpreter extends MeshInterpreter {
-    static type = InstancedMeshDescriptor.type
+export class InstancedMeshInterpreter extends MeshInterpreter {
+    static type = InstancedMesh.type
 
     readonly wrapper!: Object3D
-    instancedMesh!: InstancedMesh
+    instancedMesh!: ThreeInstancedMesh
     count = -1
 
-    createActor(descriptor: InstancedMeshDescriptor) {
+    createActor(descriptor: InstancedMesh) {
         const actor = new NodeActor(new Object3D())
         //@ts-ignore
         this.wrapper = new Object3D()
@@ -21,12 +21,12 @@ class InstancedMeshInterpreter extends MeshInterpreter {
         return actor
     }
 
-    updateInstanceMesh(setting: InstancedSetting[], instance: InstancedMesh) {
+    updateInstanceMesh(data: InstancedData[], instance: ThreeInstancedMesh) {
         const color = new Color()
         const matrix = new Matrix4()
 
-        for (let i = 0; i < setting.length; i++) {
-            const setItem = setting[i]
+        for (let i = 0; i < data.length; i++) {
+            const setItem = data[i]
             color.setStyle(setItem.color)
             matrix.fromArray(setItem.matrix)
             instance.setMatrixAt(i, matrix)
@@ -37,40 +37,38 @@ class InstancedMeshInterpreter extends MeshInterpreter {
         if (instance.instanceColor) instance.instanceColor.needsUpdate = true
     }
 
-    getInstancedMesh(descriptor: InstancedMeshDescriptor, setting: InstancedSetting[]) {
-        const instancedMesh = new InstancedMesh(geometry.defaultGeometry(), material.defaultMaterial(), setting.length)
+    getInstancedMesh(descriptor: InstancedMesh, data: InstancedData[]) {
+        const instancedMesh = new ThreeInstancedMesh(geometry.defaultGeometry(), material.defaultMaterial(), data.length)
         return instancedMesh
     }
 
-    setInstancedMesh(descriptor: InstancedMeshDescriptor) {
-        const setting = DatasetDescriptor.getCollection<InstancedSetting>(descriptor.setting)
-        if (this.count !== setting.length) {
-            this.count = setting.length
+    setInstancedMesh(descriptor: InstancedMesh) {
+        const data = Store.getCollection<InstancedData>(descriptor.data)
+        if (this.count !== data.length) {
+            this.count = data.length
             this.wrapper.clear()
             if (this.instancedMesh) this.instancedMesh.dispose()
-            this.instancedMesh = this.getInstancedMesh(descriptor,  setting)
+            this.instancedMesh = this.getInstancedMesh(descriptor,  data)
             this.wrapper.add(this.instancedMesh)
         }
-        this.updateInstanceMesh(setting, this.instancedMesh)
+        this.updateInstanceMesh(data, this.instancedMesh)
     }
 
-    update(descriptor: InstancedMeshDescriptor) {
+    update(descriptor: InstancedMesh) {
         super.update(descriptor)
         this.setInstancedMesh(descriptor)
         this.instancedMesh.geometry = geometry.getGeometry(descriptor.geometry, this.graphics)
         this.instancedMesh.material = material.getMaterial(descriptor.material, this.graphics)
     }
 
-    free(descriptor: InstancedMeshDescriptor) {
+    free(descriptor: InstancedMesh) {
         this.instancedMesh.dispose()
         super.free(descriptor)
     }
 
-    pickup(descriptor: InstancedMeshDescriptor, result: PickupNode[]) {
+    pickup(descriptor: InstancedMesh, result: PickupNode[]) {
         if (descriptor.visible === false) return
         collectionPickupResult(this.wrapper, true, descriptor, result)
     }
 }
-MeshInterpreter.register(InstancedMeshInterpreter)
-
-export { InstancedMeshInterpreter }
+MeshInterpreter.register(InstancedMeshInterpreter)

package/src/interpreter/MeshInterpreter.ts

@@ -1,24 +1,22 @@
-import { Mesh } from "three";
-import { MeshDescriptor } from "../descriptor";
-import { NodeInterpreter } from "./NodeInterpreter";
-import { NodeActor } from "../actor";
-import { geometry, material } from "../utils";
-
-class MeshInterpreter extends NodeInterpreter {
-    static type = MeshDescriptor.type
-
-    protected createActor(descriptor: MeshDescriptor): NodeActor {
-        const actor = new NodeActor(new Mesh(geometry.defaultGeometry(), material.defaultMaterial()))
-        return actor
-    }
-
-    update(descriptor: MeshDescriptor) {
-        super.update(descriptor)
-        const actor = this.getActor<NodeActor<Mesh>>(descriptor)
-        actor.object.geometry = geometry.getGeometry(descriptor.geometry, this.graphics)
-        actor.object.material = material.getMaterial(descriptor.material, this.graphics)
-    }
-}
-NodeInterpreter.register(MeshInterpreter)
-
-export { MeshInterpreter }
+import { Mesh as ThreeMesh } from "three";
+import { Mesh } from "../descriptor";
+import { NodeInterpreter } from "./NodeInterpreter";
+import { NodeActor } from "../actor";
+import { geometry, material } from "../utils";
+
+export class MeshInterpreter extends NodeInterpreter {
+    static type = Mesh.type
+
+    protected createActor(descriptor: Mesh): NodeActor {
+        const actor = new NodeActor(new ThreeMesh(geometry.defaultGeometry(), material.defaultMaterial()))
+        return actor
+    }
+
+    update(descriptor: Mesh) {
+        super.update(descriptor)
+        const actor = this.getActor<NodeActor<ThreeMesh>>(descriptor)
+        actor.object.geometry = geometry.getGeometry(descriptor.geometry, this.graphics)
+        actor.object.material = material.getMaterial(descriptor.material, this.graphics)
+    }
+}
+NodeInterpreter.register(MeshInterpreter)

package/src/interpreter/ModelInterpreter.ts

@@ -1,12 +1,12 @@
 import { Object3D } from 'three'
 import { Asset, Descriptor } from "@vyr/engine";
-import { ModelDescriptor } from "../descriptor";
+import { Model } from "../descriptor";
 import { NodeInterpreter, PickupNode } from "./NodeInterpreter";
 import { NodeActor } from '../actor';
 import { collectionPickupResult, diaposeObject3D } from '../utils'
 
-class ModelInterpreter extends NodeInterpreter {
-    static type = ModelDescriptor.type
+export class ModelInterpreter extends NodeInterpreter {
+    static type = Model.type
 
     readonly wrapper!: Object3D
     url = ''
@@ -19,7 +19,7 @@ class ModelInterpreter extends NodeInterpreter {
         return actor
     }
 
-    setModel(descriptor: ModelDescriptor) {
+    setModel(descriptor: Model) {
 
         if (this.url !== descriptor.url) {
             diaposeObject3D(this.wrapper)
@@ -41,21 +41,19 @@ class ModelInterpreter extends NodeInterpreter {
         })
     }
 
-    update(descriptor: ModelDescriptor) {
+    update(descriptor: Model) {
         super.update(descriptor)
         this.setModel(descriptor)
     }
 
-    free(descriptor: ModelDescriptor) {
+    free(descriptor: Model) {
         diaposeObject3D(this.wrapper)
         super.free(descriptor)
     }
 
-    pickup(descriptor: ModelDescriptor, result: PickupNode[]) {
+    pickup(descriptor: Model, result: PickupNode[]) {
         if (descriptor.visible === false) return
         collectionPickupResult(this.wrapper, true, descriptor, result)
     }
 }
-NodeInterpreter.register(ModelInterpreter)
-
-export { ModelInterpreter }
+NodeInterpreter.register(ModelInterpreter)

package/src/interpreter/NodeInterpreter.ts

@@ -1,22 +1,22 @@
 import { Object3D, Intersection } from "three";
-import { Descriptor, Interpreter, NodeDescriptor, PickupObject } from "@vyr/engine";
+import { Descriptor, Interpreter, Node, PickupObject } from "@vyr/engine";
 import { NodeActor } from "../actor";
 import { collectionPickupResult } from "../utils";
 
-interface PickupNode extends PickupObject {
+export interface PickupNode extends PickupObject {
     minDistance: number
     intersection: Intersection<Object3D>[]
 }
 
-class NodeInterpreter extends Interpreter {
-    static type = NodeDescriptor.type
+export class NodeInterpreter extends Interpreter {
+    static type = Node.type
 
     protected createActor(descriptor: Descriptor) {
         const actor = new NodeActor(new Object3D())
         return actor
     }
 
-    setProperty(actor: NodeActor, descriptor: NodeDescriptor) {
+    setProperty(actor: NodeActor, descriptor: Node) {
         actor.object.layers.set(descriptor.layer)
         actor.object.visible = descriptor.visible
         actor.object.renderOrder = descriptor.renderOrder
@@ -24,7 +24,7 @@ class NodeInterpreter extends Interpreter {
         actor.object.receiveShadow = descriptor.receiveShadow
     }
 
-    setTransform(actor: NodeActor, descriptor: NodeDescriptor) {
+    setTransform(actor: NodeActor, descriptor: Node) {
         const scale = descriptor.scale
         const position = descriptor.position
         const rotation = descriptor.rotation
@@ -33,33 +33,31 @@ class NodeInterpreter extends Interpreter {
         actor.object.rotation.set(rotation.x, rotation.y, rotation.z)
     }
 
-    update(descriptor: NodeDescriptor) {
+    update(descriptor: Node) {
         super.update(descriptor)
         const actor = this.getActor<NodeActor>(descriptor)
         this.setProperty(actor, descriptor)
         this.setTransform(actor, descriptor)
     }
 
-    mount(descriptor: NodeDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+    mount(descriptor: Node, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
         super.mount(descriptor,  parentInterpreter, parentDescriptor)
         const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor)
         const actor = this.getActor<NodeActor>(descriptor)
         parenActor.add(actor)
     }
 
-    unmount(descriptor: NodeDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+    unmount(descriptor: Node, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
         const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor)
         const actor = this.getActor<NodeActor>(descriptor)
         parenActor.remove(actor)
         super.unmount(descriptor,  parentInterpreter, parentDescriptor)
     }
 
-    pickup(descriptor: NodeDescriptor, result: PickupNode[]) {
+    pickup(descriptor: Node, result: PickupNode[]) {
         if (descriptor.visible === false) return
         const actor = this.getActor<NodeActor>(descriptor)
         collectionPickupResult(actor.object, false, descriptor, result)
     }
 }
-Interpreter.register(NodeInterpreter)
-
-export { PickupNode, NodeInterpreter }
+Interpreter.register(NodeInterpreter)