@vyr/three 0.0.1 → 0.0.2

package/package.json

@@ -1,26 +1 @@
-{
-  "name": "@vyr/three",
-  "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",
-    "postprocessing": "^6.38.0",
-    "three": "0.175.0"
-  },
-  "devDependencies": {
-    "@types/three": "0.175.0"
-  },
-  "files": [
-    "package.json",
-    "src/"
-  ],
-  "vyr": {
-    "type": "universal",
-    "order": 10
-  }
-}
+{"name":"@vyr/three","version":"0.0.2","description":"","main":"./src/index.ts","author":"","sideEffects":true,"license":"MIT","dependencies":{"@vyr/locale":"0.0.2","@vyr/engine":"0.0.2","postprocessing":"^6.38.0","three":"0.175.0"},"devDependencies":{"@types/three":"0.175.0"},"files":["package.json","src/"],"vyr":{"type":"universal","order":10}}

package/src/actor/ComposerServiceActor.ts

@@ -1,5 +1,5 @@
 import { EffectComposer, RenderPass, EffectPass, SMAAEffect, SMAAPreset, EdgeDetectionMode, PredicationMode } from 'postprocessing'
-import { Actor, ArrayUtils, Descriptor, UpdateArgs } from '@vyr/engine';
+import { Actor, ArrayUtils, Descriptor } from '@vyr/engine';
 import { ComposerServiceDescriptor } from '../descriptor/ComposerServiceDescriptor';
 import { SceneServiceActor } from "./SceneServiceActor";
 import { PassActor } from './PassActor';
@@ -65,12 +65,12 @@ class ComposerServiceActor extends SceneServiceActor {
         }
     }
 
-    update(descriptor: ComposerServiceDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
+    update(descriptor: ComposerServiceDescriptor) {
+        super.update(descriptor)
 
         const graphics = Actor.getGraphics(this)
         const camera = Descriptor.get<Descriptor>(graphics.scheduler.camera)
-        const cameraActor = graphics.getActor<NodeActor<Camera>>(camera, args)
+        const cameraActor = graphics.getActor<NodeActor<Camera>>(camera)
 
         const composer = this.getEffectComposer(descriptor)
         composer.addPass(this._renderPass)
@@ -83,9 +83,10 @@ class ComposerServiceActor extends SceneServiceActor {
         composer.setMainCamera(cameraActor.object)
     }
 
-    render(service: ComposerServiceDescriptor, camera: NodeActor<Camera>, args: UpdateArgs) {
+    render(service: ComposerServiceDescriptor, camera: NodeActor<Camera>) {
+        const graphics = SceneServiceActor.getGraphics(this)
         const composer = this.getEffectComposer(service)
-        composer.render(args.delta)
+        composer.render(graphics.args.delta)
         this.screenPipeline.render(this.scene, camera.object)
     }
 

package/src/actor/HTMLConvertActor.ts

@@ -1,6 +1,6 @@
 import { Object3D } from 'three'
 import { CSS3DSprite } from 'three/examples/jsm/renderers/CSS3DRenderer.js'
-import { Actor, ArrayUtils, Descriptor, HTMLActor, Interpreter, UpdateArgs } from "@vyr/engine"
+import { Actor, ArrayUtils, Descriptor, HTMLActor, Interpreter } from "@vyr/engine"
 import { NodeActor } from "./NodeActor"
 
 class HTMLConvertActor extends NodeActor {
@@ -9,9 +9,9 @@ class HTMLConvertActor extends NodeActor {
     private _sprite: CSS3DSprite | null = null
     private _collection: Actor[] = []
 
-    overrideUpdate = (descriptor: Descriptor, interpreter: Interpreter, args: UpdateArgs) => {
-        interpreter.update(descriptor, args)
-        const actor = interpreter.getActor<HTMLActor>(descriptor, args)
+    overrideUpdate = (descriptor: Descriptor, interpreter: Interpreter) => {
+        interpreter.update(descriptor)
+        const actor = interpreter.getActor<HTMLActor>(descriptor)
         const wrapper = actor.getWrapper()
         if (wrapper === null) return
         wrapper.style.position = ''

package/src/actor/OrbitControllerActor.ts

@@ -1,5 +1,5 @@
 import { Object3D } from "three";
-import { Actor, CameraDescriptor, Graphics, UpdateArgs } from "@vyr/engine"
+import { Actor, CameraDescriptor, Graphics, TickArgs } from "@vyr/engine"
 import { OrbitControllerDescriptor, SceneServiceDescriptor } from "../descriptor";
 import { CameraControls } from '../controls'
 import { SceneServiceActor } from "./SceneServiceActor";
@@ -17,25 +17,25 @@ class OrbitControllerActor extends Actor {
     this.controls.addEventListener('update', this._onUpdate)
   }
 
-  private _getCameraDescriptor(uuid: string, graphics: Graphics, args: UpdateArgs) {
-    return graphics.variableProxy.get<CameraDescriptor>(uuid, graphics, args)
+  private _getCameraDescriptor(uuid: string, graphics: Graphics) {
+    return graphics.variableProxy.get<CameraDescriptor>(uuid, graphics)
   }
-  private _getWrapper(descriptor: OrbitControllerDescriptor, graphics: Graphics, args: UpdateArgs) {
+  private _getWrapper(descriptor: OrbitControllerDescriptor, graphics: Graphics) {
     let wrapper
     const service = graphics.traceService(descriptor)
     if (service instanceof SceneServiceDescriptor) {
       const interpreter = graphics.getInterpreter(service)
-      const actor = interpreter.getActor<SceneServiceActor>(service, args)
+      const actor = interpreter.getActor<SceneServiceActor>(service)
       wrapper = actor.getWrapper()
     }
     return wrapper as HTMLElement
   }
-  private _onBeforeRender = (args: UpdateArgs) => {
+  private _onBeforeRender = (args: TickArgs) => {
     this.controls.update(args.delta)
   }
-  private _onUpdate = (args: UpdateArgs) => {
+  private _onUpdate = () => {
     const graphics = Actor.getGraphics(this)
-    const camera = this._getCameraDescriptor(graphics.scheduler.camera, graphics, args)
+    const camera = this._getCameraDescriptor(graphics.scheduler.camera, graphics)
     if (camera === null) return
     camera.position.x = this.controls.camera.position.x
     camera.position.y = this.controls.camera.position.y
@@ -47,15 +47,15 @@ class OrbitControllerActor extends Actor {
     camera.scale.y = this.controls.camera.scale.y
     camera.scale.z = this.controls.camera.scale.z
   }
-  getCamera(graphics: Graphics, args: UpdateArgs) {
-    const camera = this._getCameraDescriptor(graphics.scheduler.camera, graphics, args)
+  getCamera(graphics: Graphics) {
+    const camera = this._getCameraDescriptor(graphics.scheduler.camera, graphics)
     const interpreter = graphics.getInterpreter(camera)
-    interpreter.update(camera, args)
-    const actor = interpreter.getActor<NodeActor<any>>(camera, args)
+    interpreter.update(camera)
+    const actor = interpreter.getActor<NodeActor<any>>(camera)
     return actor.object
   }
 
-  listen(descriptor: OrbitControllerDescriptor, graphics: Graphics, args: UpdateArgs) {
+  listen(descriptor: OrbitControllerDescriptor, graphics: Graphics) {
     this.controls.minZoom = descriptor.minZoom
     this.controls.maxZoom = descriptor.maxZoom
     this.controls.minPolarAngle = descriptor.minPolarAngle
@@ -83,21 +83,21 @@ class OrbitControllerActor extends Actor {
     this.controls.infinityDolly = descriptor.infinityDolly
     this.controls.restThreshold = descriptor.restThreshold
 
-    const camera = this.getCamera(graphics, args)
+    const camera = this.getCamera(graphics)
     if (this.controls.camera !== camera) this.controls.listen(camera)
-    this.controls.connect(this._getWrapper(descriptor, graphics, args))
+    this.controls.connect(this._getWrapper(descriptor, graphics))
     graphics.engine.listen('beforeRender', this._onBeforeRender)
   }
 
-  unlisten(descriptor: OrbitControllerDescriptor, graphics: Graphics, args: UpdateArgs) {
+  unlisten(descriptor: OrbitControllerDescriptor, graphics: Graphics) {
     this.controls.disconnect()
     graphics.engine.unlisten('beforeRender', this._onBeforeRender)
   }
 
-  update(descriptor: OrbitControllerDescriptor, graphics: Graphics, args: UpdateArgs) {
-    this.unlisten(descriptor, graphics, args)
+  update(descriptor: OrbitControllerDescriptor, graphics: Graphics) {
+    this.unlisten(descriptor, graphics)
     if (descriptor.enabled === false) return
-    this.listen(descriptor, graphics, args)
+    this.listen(descriptor, graphics)
   }
 
   dispose() {

package/src/actor/SceneServiceActor.ts

@@ -1,6 +1,6 @@
 import { Camera, LinearToneMapping, Object3D, Scene, SRGBColorSpace, WebGLRenderer } from "three"
 import { CSS3DRenderer } from 'three/examples/jsm/renderers/CSS3DRenderer.js'
-import { HTMLActor, UpdateArgs, Actor, Asset } from "@vyr/engine"
+import { HTMLActor, Actor, Asset } from "@vyr/engine"
 import { SceneServiceDescriptor, TextureDescriptor } from "../descriptor"
 import { TextureActor } from "./TextureActor"
 import { NodeActor } from "./NodeActor"
@@ -90,26 +90,26 @@ class SceneServiceActor extends HTMLActor {
         }
     }
 
-    setBackground(descriptor: SceneServiceDescriptor, args: UpdateArgs) {
+    setBackground(descriptor: SceneServiceDescriptor) {
         if (descriptor.background) {
             const graphics = Actor.getGraphics(this)
             const texture = Asset.get<TextureDescriptor>(descriptor.background)
-            const actor = graphics.getActor<TextureActor>(texture, args)
+            const actor = graphics.getActor<TextureActor>(texture)
             this.scene.background = texture instanceof TextureDescriptor ? actor.object : null
         } else {
             this.scene.background = null
         }
     }
 
-    update(descriptor: SceneServiceDescriptor, args: UpdateArgs) {
+    update(descriptor: SceneServiceDescriptor) {
         const wrapper = this.getWrapper()
-        this.setHTMLStyle(wrapper, this.getWrapperStyle(descriptor, args))
-        this.setHTMLStyle(this.pipeline.domElement, this.getLayoutStyle(descriptor, args))
-        this.setStyleClass(this.pipeline.domElement, this.getStyleClass(descriptor, args))
-        this.setBackground(descriptor, args)
+        this.setHTMLStyle(wrapper, this.getWrapperStyle(descriptor))
+        this.setHTMLStyle(this.pipeline.domElement, this.getLayoutStyle(descriptor))
+        this.setStyleClass(this.pipeline.domElement, this.getStyleClass(descriptor))
+        this.setBackground(descriptor)
     }
 
-    render(service: SceneServiceDescriptor, camera: NodeActor<Camera>, args: UpdateArgs) {
+    render(service: SceneServiceDescriptor, camera: NodeActor<Camera>) {
         this.pipeline.render(this.scene, camera.object)
         this.screenPipeline.render(this.scene, camera.object)
     }

package/src/actor/TransformControllerActor.ts

@@ -1,14 +1,14 @@
-import { Actor, Graphics, UpdateArgs } from "@vyr/engine"
+import { Actor, Graphics } from "@vyr/engine"
 import { TransformControllerDescriptor } from "../descriptor"
 import { TransformControls } from "../controls"
 
 class TransformControllerActor extends Actor {
   readonly object = new TransformControls()
 
-  update(descriptor: TransformControllerDescriptor, graphics: Graphics, args: UpdateArgs) {
+  update(descriptor: TransformControllerDescriptor, graphics: Graphics) {
     this.object.unlisten(graphics)
     if (descriptor.enabled === false) return
-    this.object.listen(descriptor, graphics, args)
+    this.object.listen(descriptor, graphics)
   }
 
   unlisten(graphics: Graphics) {

package/src/controls/TransformControls.ts

@@ -21,7 +21,7 @@ import {
     TorusGeometry,
     Vector3,
 } from 'three'
-import { Asset, NodeDescriptor, UpdateArgs, ServiceDescriptor, Graphics, Scriptable, Descriptor } from '@vyr/engine'
+import { Asset, NodeDescriptor, ServiceDescriptor, Graphics, Scriptable, Descriptor } from '@vyr/engine'
 import { TransformControllerChangeArgs, TransformControllerDescriptor, SceneServiceDescriptor, OrbitControllerDescriptor } from '../descriptor'
 import { NodeActor, SceneServiceActor } from '../actor'
 
@@ -1255,24 +1255,24 @@ class TransformControls extends Object3D {
         this.sourceTarget.rotation.y = this.object.rotation.y
         this.sourceTarget.rotation.z = this.object.rotation.z
 
-        const _args: TransformControllerChangeArgs = { ...this.args, event: { type, target: this.descriptor.target } }
-        this.scriptable.execute(this.descriptor, this.graphics, _args)
+        const _args: TransformControllerChangeArgs = { event: { type, target: this.descriptor.target }, trigger: this.sourceTarget }
+        this.scriptable.execute(this.graphics, _args)
     }
 
-    listen(descriptor: TransformControllerDescriptor, graphics: Graphics, args: UpdateArgs) {
+    listen(descriptor: TransformControllerDescriptor, graphics: Graphics) {
         this.unlisten(graphics)
 
-        const sourceTarget = graphics.variableProxy.get<NodeDescriptor>(descriptor.target, graphics, args)
+        const sourceTarget = graphics.variableProxy.get<NodeDescriptor>(descriptor.target, graphics)
         if (sourceTarget === null) return
-        const sourceTargetActor = graphics.getActor(sourceTarget, args)
+        const sourceTargetActor = graphics.getActor(sourceTarget)
         if (sourceTargetActor instanceof NodeActor) {
-            const camera = graphics.variableProxy.get<NodeDescriptor>(graphics.scheduler.camera, graphics, args)
-            const actor = graphics.getActor(camera, args) as NodeActor
+            const camera = graphics.variableProxy.get<NodeDescriptor>(graphics.scheduler.camera, graphics)
+            const actor = graphics.getActor(camera) as NodeActor
             const scriptable = Asset.get(descriptor.event)
 
             this.setCustomProperty('camera', actor.object)
             this.setCustomProperty('graphics', graphics)
-            this.setCustomProperty('args', args)
+            this.setCustomProperty('args')
             this.setCustomProperty('descriptor', descriptor)
             this.setCustomProperty('mode', descriptor.mode)
             this.setCustomProperty('scriptable', scriptable)
@@ -1281,7 +1281,7 @@ class TransformControls extends Object3D {
 
             this.attach(sourceTargetActor.object)
 
-            this.domElement = this.getWrapper(descriptor, graphics, args)
+            this.domElement = this.getWrapper(descriptor, graphics)
 
             this.events.push(graphics.engine.inputSystem.listen('pointerdown', this._onPointerDown, { target: this.domElement }))
             this.events.push(graphics.engine.inputSystem.listen('pointerdown', this._onPointerDown, { target: this.domElement }))
@@ -1300,10 +1300,6 @@ class TransformControls extends Object3D {
         this.setCustomProperty('enabled', false)
     }
 
-    // update(descriptor: TransformControllerDescriptor, graphics: Graphics, args: UpdateArgs) {
-    //     this.listen(descriptor, graphics, args)
-    // }
-
     unbind(graphics: Graphics) {
         for (const e of this.events) graphics.engine.inputSystem.unlisten(e)
         this.events.length = 0
@@ -1320,12 +1316,12 @@ class TransformControls extends Object3D {
         })
     }
 
-    private getWrapper(descriptor: TransformControllerDescriptor, graphics: Graphics, args: UpdateArgs) {
+    private getWrapper(descriptor: TransformControllerDescriptor, graphics: Graphics) {
         let wrapper
         const service = graphics.traceService(descriptor)
         if (service instanceof SceneServiceDescriptor) {
             const interpreter = graphics.getInterpreter(service)
-            const actor = interpreter.getActor<SceneServiceActor>(service, args)
+            const actor = interpreter.getActor<SceneServiceActor>(service)
             wrapper = actor.getWrapper()
         }
         return wrapper as HTMLElement

package/src/descriptor/OrbitControllerDescriptor.ts

@@ -1,6 +1,6 @@
-import { ControllerDescriptor, DeserializationObject, UpdateArgs, Vector3 } from "@vyr/engine";
+import { ControllerDescriptor, DeserializationObject, ScriptableArgs } from "@vyr/engine";
 
-interface OrbitControllerChangeArgs extends UpdateArgs {
+interface OrbitControllerChangeArgs extends ScriptableArgs<undefined, undefined, undefined> {
   event: {
     type: string,
     target: string

package/src/descriptor/TransformControllerDescriptor.ts

@@ -1,6 +1,6 @@
-import { ControllerDescriptor, DeserializationObject, UpdateArgs } from "@vyr/engine";
+import { ControllerDescriptor, DeserializationObject, ScriptableArgs } from "@vyr/engine";
 
-interface TransformControllerChangeArgs extends UpdateArgs {
+interface TransformControllerChangeArgs extends ScriptableArgs {
   event: {
     type: string,
     target: string

package/src/interpreter/ComposerServiceInterpreter.ts

@@ -6,7 +6,7 @@
 // class ComposerServiceInterpreter extends SceneServiceInterpreter {
 //     static type = ComposerServiceDescriptor.type
 
-//     protected createActor(descriptor: ComposerServiceDescriptor, args: UpdateArgs) {
+//     protected createActor(descriptor: ComposerServiceDescriptor) {
 //         const actor = new ComposerServiceActor(descriptor)
 //         return actor
 //     }

package/src/interpreter/GeoMapInterpreter.ts

@@ -1,10 +1,10 @@
 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, RoutineDescriptor, RoutineNode, Unit, UpdateArgs, Vector2 } from "@vyr/engine";
+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 { NodeInterpreter, PickupNode } from "./NodeInterpreter";
 import { material, diaposeObject3D, collectionPickupResult } from "../utils";
 import { NodeActor } from "../actor";
-import { executePreset, routinePreset } from "../preset";
+import { executePreset, interactionPreset } from "../preset";
 
 interface GeoFeature<T extends BufferGeometry = BufferGeometry> {
     url: string
@@ -71,9 +71,9 @@ class GeoMapInterpreter extends NodeInterpreter {
     readonly wrapper = new Object3D()
     readonly features: GeoFeature[] = []
     readonly labels: HTMLConvertDescriptor[] = []
-    readonly routines: RoutineDescriptor[] = []
+    readonly interactions: InteractionDescriptor[] = []
 
-    protected createActor(descriptor: Descriptor, args: UpdateArgs) {
+    protected createActor(descriptor: Descriptor) {
         const actor = new NodeActor(new Object3D())
         actor.object.add(this.wrapper)
         return actor
@@ -100,7 +100,7 @@ class GeoMapInterpreter extends NodeInterpreter {
         Asset.set(datasetUrl, dataset)
 
         const inputs = {
-            [routinePreset.GeoMap.drilldown.nodes.drilldown]: executePreset.GeoMap.drilldown.createExecuteInput({
+            [interactionPreset.GeoMap.drilldown.nodes.drilldown]: executePreset.GeoMap.drilldown.createExecuteInput({
                 dataset,
                 geoMap: descriptor,
             })
@@ -110,7 +110,7 @@ class GeoMapInterpreter extends NodeInterpreter {
             sub.interactions.push({
                 uuid: Generate.uuid(),
                 type: "click",
-                url: routinePreset.GeoMap.drilldown.url,
+                url: interactionPreset.GeoMap.drilldown.url,
                 inputs,
             })
         })
@@ -124,7 +124,7 @@ class GeoMapInterpreter extends NodeInterpreter {
         }
         return data
     }
-    buildLabel(descriptor: GeoMapDescriptor, fullJson: JsonAsset, offset: Vector2, args: UpdateArgs) {
+    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)
@@ -139,7 +139,7 @@ class GeoMapInterpreter extends NodeInterpreter {
         }
     }
 
-    buildFeature(feature: JsonAsset, materials: Material | Material[], offset: Vector2, factory: GeometryFactory, args: UpdateArgs, flag: string) {
+    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}`)
 
@@ -150,8 +150,8 @@ class GeoMapInterpreter extends NodeInterpreter {
         const interpreter = Graphics.createInterpreter(geometry, this.graphics)
         //@ts-ignore
         interpreter.unit = new Unit(geometry.uuid, '', this.unit.queue)
-        interpreter.update(geometry, args)
-        const actor = interpreter.getActor(geometry, args)
+        interpreter.update(geometry)
+        const actor = interpreter.getActor(geometry)
 
         const mesh = new Mesh(actor.object, materials)
 
@@ -162,48 +162,48 @@ class GeoMapInterpreter extends NodeInterpreter {
         return item
     }
 
-    buildBorder(fullJson: JsonAsset, materials: Material | Material[], offset: Vector2, features: GeoFeature[], args: UpdateArgs) {
+    buildBorder(fullJson: JsonAsset, materials: Material | Material[], offset: Vector2, features: GeoFeature[]) {
         for (const feature of fullJson.features) {
-            const item = this.buildFeature(feature, materials, offset, tubeFactory, args, '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, args: UpdateArgs) {
-        const region = this.buildFeature(feature, materials, offset, shadowFactory, args, 'shadow')
+    buildShadow(feature: JsonAsset, materials: Material | Material[], offset: Vector2) {
+        const region = this.buildFeature(feature, materials, offset, shadowFactory,  'shadow')
         this.features.push(region)
         return region
     }
 
-    buildRegion(feature: JsonAsset, materials: Material | Material[], offset: Vector2, args: UpdateArgs) {
-        const region = this.buildFeature(feature, materials, offset, extrudeFactory, args, 'region')
+    buildRegion(feature: JsonAsset, materials: Material | Material[], offset: Vector2) {
+        const region = this.buildFeature(feature, materials, offset, extrudeFactory,  'region')
         this.features.push(region)
         return region
     }
 
-    async build(descriptor: GeoMapDescriptor, args: UpdateArgs) {
+    async build(descriptor: GeoMapDescriptor) {
         const geojson = Asset.get<JsonAsset>(descriptor.geojsonRegion)
         if (Array.isArray(geojson.features) === false || geojson.features.length === 0) return
 
-        const regionMaterials = material.getMaterial(descriptor.material, this.graphics, args)
-        const borderMaterial = descriptor.borderMaterial ? material.getMaterial(descriptor.borderMaterial, this.graphics, args) : regionMaterials
+        const regionMaterials = material.getMaterial(descriptor.material, this.graphics)
+        const borderMaterial = descriptor.borderMaterial ? material.getMaterial(descriptor.borderMaterial, this.graphics) : regionMaterials
 
         const regionJson = geojson.features[0]
         const offset = new Vector2(-regionJson.properties.centroid[0], -regionJson.properties.centroid[1])
-        const region = this.buildRegion(regionJson, regionMaterials, offset, args)
+        const region = this.buildRegion(regionJson, regionMaterials, offset)
         region.mesh.castShadow = descriptor.castShadow
 
         if (descriptor.shadowMaterial) {
-            const shadowMaterials = material.getMaterial(descriptor.shadowMaterial, this.graphics, args)
-            const shadow = this.buildShadow(regionJson, shadowMaterials, offset, args)
+            const shadowMaterials = material.getMaterial(descriptor.shadowMaterial, this.graphics)
+            const shadow = this.buildShadow(regionJson, shadowMaterials, offset)
             shadow.mesh.receiveShadow = descriptor.castShadow
         }
 
         const fullJson = Asset.get<JsonAsset>(descriptor.geojsonBorder)
         if (fullJson !== null && Array.isArray(fullJson.features)) {
-            if (descriptor.label) this.buildLabel(descriptor, fullJson, offset, args)
-            this.buildBorder(fullJson, borderMaterial, offset, this.features, args)
+            if (descriptor.label) this.buildLabel(descriptor, fullJson, offset)
+            this.buildBorder(fullJson, borderMaterial, offset, this.features)
         }
     }
 
@@ -223,27 +223,27 @@ class GeoMapInterpreter extends NodeInterpreter {
         if (this._task !== null) this._task.cancel()
     }
 
-    update(descriptor: GeoMapDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
+    update(descriptor: GeoMapDescriptor) {
+        super.update(descriptor)
 
         this.wrapper.layers.set(descriptor.layer)
         this.wrapper.visible = descriptor.visible
 
         this.clear()
-        if (descriptor.geojsonRegion) this.build(descriptor, args)
+        if (descriptor.geojsonRegion) this.build(descriptor)
     }
 
-    unmount(descriptor: GeoMapDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+    unmount(descriptor: GeoMapDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
         this.clear()
-        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+        super.unmount(descriptor,  parentInterpreter, parentDescriptor)
     }
 
-    free(descriptor: GeoMapDescriptor, args: UpdateArgs) {
+    free(descriptor: GeoMapDescriptor) {
         this.clear()
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 
-    pickup(descriptor: GeoMapDescriptor, args: UpdateArgs, result: PickupNode[]) {
+    pickup(descriptor: GeoMapDescriptor, result: PickupNode[]) {
         if (descriptor.visible === false) return
         collectionPickupResult(this.wrapper, true, descriptor, result)
     }

package/src/interpreter/HTMLConvertInterpreter.ts

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

package/src/interpreter/InstancedMeshInterpreter.ts

@@ -1,5 +1,5 @@
 import { Color, InstancedMesh, Matrix4, Object3D } from 'three'
-import { DatasetDescriptor, UpdateArgs } from "@vyr/engine";
+import { DatasetDescriptor } from "@vyr/engine";
 import { InstancedMeshDescriptor, InstancedSetting } from "../descriptor";
 import { PickupNode } from './NodeInterpreter';
 import { MeshInterpreter } from "./MeshInterpreter";
@@ -13,7 +13,7 @@ class InstancedMeshInterpreter extends MeshInterpreter {
     instancedMesh!: InstancedMesh
     count = -1
 
-    createActor(descriptor: InstancedMeshDescriptor, args: UpdateArgs) {
+    createActor(descriptor: InstancedMeshDescriptor) {
         const actor = new NodeActor(new Object3D())
         //@ts-ignore
         this.wrapper = new Object3D()
@@ -37,36 +37,36 @@ class InstancedMeshInterpreter extends MeshInterpreter {
         if (instance.instanceColor) instance.instanceColor.needsUpdate = true
     }
 
-    getInstancedMesh(descriptor: InstancedMeshDescriptor, args: UpdateArgs, setting: InstancedSetting[]) {
+    getInstancedMesh(descriptor: InstancedMeshDescriptor, setting: InstancedSetting[]) {
         const instancedMesh = new InstancedMesh(geometry.defaultGeometry(), material.defaultMaterial(), setting.length)
         return instancedMesh
     }
 
-    setInstancedMesh(descriptor: InstancedMeshDescriptor, args: UpdateArgs) {
+    setInstancedMesh(descriptor: InstancedMeshDescriptor) {
         const setting = DatasetDescriptor.getCollection<InstancedSetting>(descriptor.setting)
         if (this.count !== setting.length) {
             this.count = setting.length
             this.wrapper.clear()
             if (this.instancedMesh) this.instancedMesh.dispose()
-            this.instancedMesh = this.getInstancedMesh(descriptor, args, setting)
+            this.instancedMesh = this.getInstancedMesh(descriptor,  setting)
             this.wrapper.add(this.instancedMesh)
         }
         this.updateInstanceMesh(setting, this.instancedMesh)
     }
 
-    update(descriptor: InstancedMeshDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        this.setInstancedMesh(descriptor, args)
-        this.instancedMesh.geometry = geometry.getGeometry(descriptor.geometry, this.graphics, args)
-        this.instancedMesh.material = material.getMaterial(descriptor.material, this.graphics, args)
+    update(descriptor: InstancedMeshDescriptor) {
+        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, args: UpdateArgs) {
+    free(descriptor: InstancedMeshDescriptor) {
         this.instancedMesh.dispose()
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 
-    pickup(descriptor: InstancedMeshDescriptor, args: UpdateArgs, result: PickupNode[]) {
+    pickup(descriptor: InstancedMeshDescriptor, result: PickupNode[]) {
         if (descriptor.visible === false) return
         collectionPickupResult(this.wrapper, true, descriptor, result)
     }

package/src/interpreter/MeshInterpreter.ts

@@ -1,5 +1,4 @@
 import { Mesh } from "three";
-import { UpdateArgs } from "@vyr/engine";
 import { MeshDescriptor } from "../descriptor";
 import { NodeInterpreter } from "./NodeInterpreter";
 import { NodeActor } from "../actor";
@@ -8,16 +7,16 @@ import { geometry, material } from "../utils";
 class MeshInterpreter extends NodeInterpreter {
     static type = MeshDescriptor.type
 
-    protected createActor(descriptor: MeshDescriptor, args: UpdateArgs): NodeActor {
+    protected createActor(descriptor: MeshDescriptor): NodeActor {
         const actor = new NodeActor(new Mesh(geometry.defaultGeometry(), material.defaultMaterial()))
         return actor
     }
 
-    update(descriptor: MeshDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<NodeActor<Mesh>>(descriptor, args)
-        actor.object.geometry = geometry.getGeometry(descriptor.geometry, this.graphics, args)
-        actor.object.material = material.getMaterial(descriptor.material, this.graphics, args)
+    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)