@vyr/three 0.0.1 → 0.0.2

package/src/interpreter/ModelInterpreter.ts

@@ -1,5 +1,5 @@
 import { Object3D } from 'three'
-import { Asset, Descriptor, UpdateArgs } from "@vyr/engine";
+import { Asset, Descriptor } from "@vyr/engine";
 import { ModelDescriptor } from "../descriptor";
 import { NodeInterpreter, PickupNode } from "./NodeInterpreter";
 import { NodeActor } from '../actor';
@@ -11,15 +11,15 @@ class ModelInterpreter extends NodeInterpreter {
     readonly wrapper!: Object3D
     url = ''
 
-    protected createActor(descriptor: Descriptor, args: UpdateArgs) {
-        const actor = super.createActor(descriptor, args)
+    protected createActor(descriptor: Descriptor) {
+        const actor = super.createActor(descriptor)
         //@ts-ignore
         this.wrapper = new Object3D()
         actor.object.add(this.wrapper)
         return actor
     }
 
-    setModel(descriptor: ModelDescriptor, args: UpdateArgs) {
+    setModel(descriptor: ModelDescriptor) {
 
         if (this.url !== descriptor.url) {
             diaposeObject3D(this.wrapper)
@@ -41,17 +41,17 @@ class ModelInterpreter extends NodeInterpreter {
         })
     }
 
-    update(descriptor: ModelDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        this.setModel(descriptor, args)
+    update(descriptor: ModelDescriptor) {
+        super.update(descriptor)
+        this.setModel(descriptor)
     }
 
-    free(descriptor: ModelDescriptor, args: UpdateArgs) {
+    free(descriptor: ModelDescriptor) {
         diaposeObject3D(this.wrapper)
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 
-    pickup(descriptor: ModelDescriptor, args: UpdateArgs, result: PickupNode[]) {
+    pickup(descriptor: ModelDescriptor, result: PickupNode[]) {
         if (descriptor.visible === false) return
         collectionPickupResult(this.wrapper, true, descriptor, result)
     }

package/src/interpreter/NodeInterpreter.ts

@@ -1,5 +1,5 @@
 import { Object3D, Intersection } from "three";
-import { Descriptor, Interpreter, NodeDescriptor, PickupObject, UpdateArgs } from "@vyr/engine";
+import { Descriptor, Interpreter, NodeDescriptor, PickupObject } from "@vyr/engine";
 import { NodeActor } from "../actor";
 import { collectionPickupResult } from "../utils";
 
@@ -11,12 +11,12 @@ interface PickupNode extends PickupObject {
 class NodeInterpreter extends Interpreter {
     static type = NodeDescriptor.type
 
-    protected createActor(descriptor: Descriptor, args: UpdateArgs) {
+    protected createActor(descriptor: Descriptor) {
         const actor = new NodeActor(new Object3D())
         return actor
     }
 
-    setProperty(actor: NodeActor, descriptor: NodeDescriptor, args: UpdateArgs) {
+    setProperty(actor: NodeActor, descriptor: NodeDescriptor) {
         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, args: UpdateArgs) {
+    setTransform(actor: NodeActor, descriptor: NodeDescriptor) {
         const scale = descriptor.scale
         const position = descriptor.position
         const rotation = descriptor.rotation
@@ -33,30 +33,30 @@ class NodeInterpreter extends Interpreter {
         actor.object.rotation.set(rotation.x, rotation.y, rotation.z)
     }
 
-    update(descriptor: NodeDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<NodeActor>(descriptor, args)
-        this.setProperty(actor, descriptor, args)
-        this.setTransform(actor, descriptor, args)
+    update(descriptor: NodeDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<NodeActor>(descriptor)
+        this.setProperty(actor, descriptor)
+        this.setTransform(actor, descriptor)
     }
 
-    mount(descriptor: NodeDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
-        const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor, args)
-        const actor = this.getActor<NodeActor>(descriptor, args)
+    mount(descriptor: NodeDescriptor, 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, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor, args)
-        const actor = this.getActor<NodeActor>(descriptor, args)
+    unmount(descriptor: NodeDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor)
+        const actor = this.getActor<NodeActor>(descriptor)
         parenActor.remove(actor)
-        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+        super.unmount(descriptor,  parentInterpreter, parentDescriptor)
     }
 
-    pickup(descriptor: NodeDescriptor, args: UpdateArgs, result: PickupNode[]) {
+    pickup(descriptor: NodeDescriptor, result: PickupNode[]) {
         if (descriptor.visible === false) return
-        const actor = this.getActor<NodeActor>(descriptor, args)
+        const actor = this.getActor<NodeActor>(descriptor)
         collectionPickupResult(actor.object, false, descriptor, result)
     }
 }

package/src/interpreter/OrbitControllerInterpreter.ts

@@ -1,45 +1,45 @@
-import { Descriptor, Interpreter, PickupObject, UpdateArgs } from "@vyr/engine";
+import { Descriptor, Interpreter, PickupObject } from "@vyr/engine";
 import { OrbitControllerDescriptor } from "../descriptor";
 import { NodeActor, OrbitControllerActor } from "../actor";
 
 class OrbitControllerInterpreter extends Interpreter {
   static type = OrbitControllerDescriptor.type
 
-  protected createActor(descriptor: OrbitControllerDescriptor, args: UpdateArgs) {
+  protected createActor(descriptor: OrbitControllerDescriptor) {
     const actor = new OrbitControllerActor(descriptor.uuid, this.graphics)
     return actor
   }
 
-  update(descriptor: OrbitControllerDescriptor, args: UpdateArgs) {
-    const actor = this.getActor<OrbitControllerActor>(descriptor, args)
-    actor.update(descriptor, this.graphics, args)
-    super.update(descriptor, args)
+  update(descriptor: OrbitControllerDescriptor) {
+    const actor = this.getActor<OrbitControllerActor>(descriptor)
+    actor.update(descriptor, this.graphics)
+    super.update(descriptor)
   }
 
-  mount(descriptor: OrbitControllerDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-    super.mount(descriptor, args, parentInterpreter, parentDescriptor)
-    const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor, args)
-    const actor = this.getActor<OrbitControllerActor>(descriptor, args)
+  mount(descriptor: OrbitControllerDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+    super.mount(descriptor,  parentInterpreter, parentDescriptor)
+    const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor)
+    const actor = this.getActor<OrbitControllerActor>(descriptor)
     parenActor.add(actor)
-    actor.listen(descriptor, this.graphics, args)
+    actor.listen(descriptor, this.graphics)
   }
 
-  unmount(descriptor: OrbitControllerDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-    const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor, args)
-    const actor = this.getActor<OrbitControllerActor>(descriptor, args)
+  unmount(descriptor: OrbitControllerDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+    const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor)
+    const actor = this.getActor<OrbitControllerActor>(descriptor)
     parenActor.remove(actor)
-    actor.unlisten(descriptor, this.graphics, args)
+    actor.unlisten(descriptor, this.graphics)
 
-    super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+    super.unmount(descriptor,  parentInterpreter, parentDescriptor)
   }
 
-  free(descriptor: OrbitControllerDescriptor, args: UpdateArgs) {
-    const actor = this.getActor<OrbitControllerActor>(descriptor, args)
+  free(descriptor: OrbitControllerDescriptor) {
+    const actor = this.getActor<OrbitControllerActor>(descriptor)
     actor.dispose()
-    super.free(descriptor, args)
+    super.free(descriptor)
   }
 
-  pickup(descriptor: OrbitControllerDescriptor, args: UpdateArgs, result: PickupObject[]) { }
+  pickup(descriptor: OrbitControllerDescriptor, result: PickupObject[]) { }
 }
 Interpreter.register(OrbitControllerInterpreter)
 

package/src/interpreter/OrthographicCameraInterpreter.ts

@@ -1,11 +1,11 @@
-import { PickupObject, UpdateArgs } from "@vyr/engine";
+import { PickupObject } from "@vyr/engine";
 import { OrthographicCameraDescriptor } from "../descriptor";
 import { NodeInterpreter } from "./NodeInterpreter";
 
 class OrthographicCameraInterpreter extends NodeInterpreter {
     static type = OrthographicCameraDescriptor.type
 
-    pickup(descriptor: OrthographicCameraDescriptor, args: UpdateArgs, result: PickupObject[]) { }
+    pickup(descriptor: OrthographicCameraDescriptor, result: PickupObject[]) { }
 }
 NodeInterpreter.register(OrthographicCameraInterpreter)
 

package/src/interpreter/ParticleInterpreter.ts

@@ -13,7 +13,7 @@ import {
   CatmullRomCurve3,
   Vector3,
 } from "three";
-import { DatasetDescriptor, UpdateArgs } from "@vyr/engine";
+import { DatasetDescriptor, TickArgs } from "@vyr/engine";
 import { ParticleDescriptor } from "../descriptor";
 import { NodeInterpreter } from "./NodeInterpreter";
 import { NodeActor } from "../actor";
@@ -29,7 +29,7 @@ class ParticleInterpreter extends NodeInterpreter {
   private _trackTexture = { value: new DataTexture() };
   uptime = 0;
 
-  protected createActor(descriptor: ParticleDescriptor, args: UpdateArgs) {
+  protected createActor(descriptor: ParticleDescriptor) {
     const actor = new NodeActor(new Points(this._geometry, this._material));
     return actor;
   }
@@ -112,7 +112,7 @@ class ParticleInterpreter extends NodeInterpreter {
       'gl_PointSize = vSize * size;'
     );
   }
-  private _setTrackMap(descriptor: ParticleDescriptor, args: UpdateArgs) {
+  private _setTrackMap(descriptor: ParticleDescriptor) {
     this.clear();
 
     const trackData = DatasetDescriptor.getCollection<number[]>(descriptor.track);
@@ -133,10 +133,10 @@ class ParticleInterpreter extends NodeInterpreter {
     };
     this.graphics.engine.listen("beforeRender", this._updateRadio);
   }
-  private _updateMaterial(descriptor: ParticleDescriptor, args: UpdateArgs) {
-    this._setTrackMap(descriptor, args);
-    texture.setMap(this._material, "map", descriptor, this.graphics, args);
-    texture.setMap(this._material, "alphaMap", descriptor, this.graphics, args);
+  private _updateMaterial(descriptor: ParticleDescriptor) {
+    this._setTrackMap(descriptor);
+    texture.setMap(this._material, "map", descriptor, this.graphics);
+    texture.setMap(this._material, "alphaMap", descriptor, this.graphics);
     this._material.alphaTest = descriptor.alphaTest;
     this._material.transparent = descriptor.transparent;
     this._material.colorWrite = descriptor.colorWrite;
@@ -193,17 +193,17 @@ class ParticleInterpreter extends NodeInterpreter {
 
     this._geometry.copy(geometry)
   }
-  private _updateRadio = (args: UpdateArgs) => {
+  private _updateRadio = (args: TickArgs) => {
     this.uptime += args.delta;
     const currentTime = this.uptime % this._duration;
     this._tracRadio.value = currentTime / this._duration;
   };
 
-  update(descriptor: ParticleDescriptor, args: UpdateArgs) {
-    super.update(descriptor, args);
+  update(descriptor: ParticleDescriptor) {
+    super.update(descriptor);
     this._duration = descriptor.duration;
     this._updateGeometry(descriptor);
-    this._updateMaterial(descriptor, args);
+    this._updateMaterial(descriptor);
   }
 
   clear() {
@@ -211,9 +211,9 @@ class ParticleInterpreter extends NodeInterpreter {
     this._trackTexture.value.dispose();
   }
 
-  free(descriptor: ParticleDescriptor, args: UpdateArgs) {
+  free(descriptor: ParticleDescriptor) {
     this.clear();
-    super.free(descriptor, args);
+    super.free(descriptor);
   }
 }
 NodeInterpreter.register(ParticleInterpreter);

package/src/interpreter/PassInterpreter.ts

@@ -1,40 +1,40 @@
-// import { Descriptor, Interpreter, UpdateArgs } from "@vyr/engine";
+// import { Descriptor, Interpreter } from "@vyr/engine";
 // import { PassDescriptor } from '../descriptor/PassDescriptor'
 // import { ComposerServiceActor, PassActor } from "../actor"
 
 // class PassInterpreter extends Interpreter {
 //     static type = PassDescriptor.type
 
-//     protected createActor(descriptor: PassDescriptor, args: UpdateArgs) {
+//     protected createActor(descriptor: PassDescriptor) {
 //         const actor = new PassActor(descriptor)
 //         return actor
 //     }
 
-//     update(descriptor: PassDescriptor, args: UpdateArgs) {
-//         super.update(descriptor, args)
-//         const actor = this.getActor<PassActor>(descriptor, args)
+//     update(descriptor: PassDescriptor) {
+//         super.update(descriptor)
+//         const actor = this.getActor<PassActor>(descriptor)
 //         actor.update(descriptor)
 //     }
 
-//     mount(descriptor: PassDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-//         super.mount(descriptor, args, parentInterpreter, parentDescriptor)
-//         const parenActor = parentInterpreter.getActor<ComposerServiceActor>(parentDescriptor, args)
-//         const actor = this.getActor<PassActor>(descriptor, args)
+//     mount(descriptor: PassDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+//         super.mount(descriptor,  parentInterpreter, parentDescriptor)
+//         const parenActor = parentInterpreter.getActor<ComposerServiceActor>(parentDescriptor)
+//         const actor = this.getActor<PassActor>(descriptor)
 //         parenActor.add(actor)
 //     }
 
-//     unmount(descriptor: PassDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-//         const parenActor = parentInterpreter.getActor<ComposerServiceActor>(parentDescriptor, args)
-//         const actor = this.getActor<PassActor>(descriptor, args)
+//     unmount(descriptor: PassDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+//         const parenActor = parentInterpreter.getActor<ComposerServiceActor>(parentDescriptor)
+//         const actor = this.getActor<PassActor>(descriptor)
 //         parenActor.remove(actor)
 
-//         super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+//         super.unmount(descriptor,  parentInterpreter, parentDescriptor)
 //     }
 
-//     free(descriptor: PassDescriptor, args: UpdateArgs) {
-//         const actor = this.getActor<PassActor>(descriptor, args)
+//     free(descriptor: PassDescriptor) {
+//         const actor = this.getActor<PassActor>(descriptor)
 //         actor.dispose()
-//         super.free(descriptor, args)
+//         super.free(descriptor)
 //     }
 // }
 // Interpreter.register(PassInterpreter)

package/src/interpreter/PerspectiveCameraInterpreter.ts

@@ -1,5 +1,5 @@
 import { PerspectiveCamera } from "three";
-import { PickupObject, UpdateArgs } from "@vyr/engine";
+import { PickupObject } from "@vyr/engine";
 import { PerspectiveCameraDescriptor } from "../descriptor";
 import { NodeInterpreter } from "./NodeInterpreter";
 import { NodeActor } from "../actor";
@@ -7,25 +7,25 @@ import { NodeActor } from "../actor";
 class PerspectiveCameraInterpreter extends NodeInterpreter {
   static type = PerspectiveCameraDescriptor.type
 
-  protected createActor(descriptor: PerspectiveCameraDescriptor, args: UpdateArgs) {
+  protected createActor(descriptor: PerspectiveCameraDescriptor) {
     const actor = new NodeActor(new PerspectiveCamera())
     return actor
   }
 
-  setCamera(actor: NodeActor<PerspectiveCamera>, descriptor: PerspectiveCameraDescriptor, args: UpdateArgs) {
+  setCamera(actor: NodeActor<PerspectiveCamera>, descriptor: PerspectiveCameraDescriptor) {
     actor.object.fov = descriptor.fov
     actor.object.updateMatrix()
     actor.object.updateMatrixWorld()
     actor.object.updateProjectionMatrix()
   }
 
-  update(descriptor: PerspectiveCameraDescriptor, args: UpdateArgs) {
-    super.update(descriptor,args)
-    const actor = this.getActor<NodeActor<PerspectiveCamera>>(descriptor, args)
-    this.setCamera(actor, descriptor, args)
+  update(descriptor: PerspectiveCameraDescriptor) {
+    super.update(descriptor)
+    const actor = this.getActor<NodeActor<PerspectiveCamera>>(descriptor)
+    this.setCamera(actor, descriptor)
   }
 
-  pickup(descriptor: PerspectiveCameraDescriptor, args: UpdateArgs, result: PickupObject[]) { }
+  pickup(descriptor: PerspectiveCameraDescriptor, result: PickupObject[]) { }
 }
 NodeInterpreter.register(PerspectiveCameraInterpreter)
 

package/src/interpreter/PointsInterpreter.ts

@@ -1,5 +1,5 @@
 import { BufferGeometry, Points, Material, PointsMaterial } from "three";
-import { Asset, UpdateArgs } from "@vyr/engine";
+import { Asset } from "@vyr/engine";
 import { PointsDescriptor } from "../descriptor";
 import { NodeInterpreter } from "./NodeInterpreter";
 import { GeometryActor, MaterialActor, NodeActor } from "../actor";
@@ -22,38 +22,38 @@ class PointsInterpreter extends NodeInterpreter {
 
     static type = PointsDescriptor.type
     
-    protected createActor(descriptor: PointsDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: PointsDescriptor) {
         const actor = new NodeActor(new Points())
         return actor
     }
 
-    getGeometry(descriptor: PointsDescriptor, args: UpdateArgs) {
+    getGeometry(descriptor: PointsDescriptor) {
         const geometryDescriptor = Asset.get(descriptor.geometry)
         if (geometryDescriptor === null) return PointsInterpreter.geometry
 
         const interpreter = this.graphics.getInterpreter(geometryDescriptor)
-        const actor = interpreter.getActor<GeometryActor<BufferGeometry>>(geometryDescriptor, args)
+        const actor = interpreter.getActor<GeometryActor<BufferGeometry>>(geometryDescriptor)
         return actor.object instanceof BufferGeometry ? actor.object : PointsInterpreter.geometry
     }
 
-    useMaterial(material: string, args: UpdateArgs) {
+    useMaterial(material: string) {
         const materialDescriptor = Asset.get(material)
         if (materialDescriptor === null) return PointsInterpreter.material
 
         const interpreter = this.graphics.getInterpreter(materialDescriptor)
-        const actor = interpreter.getActor<MaterialActor<Material>>(materialDescriptor, args)
+        const actor = interpreter.getActor<MaterialActor<Material>>(materialDescriptor)
         return actor.object instanceof Material ? actor.object : PointsInterpreter.material
     }
 
-    getMaterial(descriptor: PointsDescriptor, args: UpdateArgs) {
-        return this.useMaterial(descriptor.material, args)
+    getMaterial(descriptor: PointsDescriptor) {
+        return this.useMaterial(descriptor.material)
     }
 
-    update(descriptor: PointsDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<NodeActor<Points>>(descriptor, args)
-        actor.object.geometry = this.getGeometry(descriptor, args)
-        actor.object.material = this.getMaterial(descriptor, args)
+    update(descriptor: PointsDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<NodeActor<Points>>(descriptor)
+        actor.object.geometry = this.getGeometry(descriptor)
+        actor.object.material = this.getMaterial(descriptor)
     }
 }
 NodeInterpreter.register(PointsInterpreter)

package/src/interpreter/SceneServiceInterpreter.ts

@@ -1,5 +1,5 @@
 import { Camera, PerspectiveCamera, Raycaster, Vector2, } from 'three'
-import { CameraDescriptor, Descriptor, HTMLActor, Interpreter, ServiceDescriptor, ServiceInterpreter, UpdateArgs } from '@vyr/engine'
+import { CameraDescriptor, Descriptor, HTMLActor, Interpreter, ServiceDescriptor, ServiceInterpreter } from '@vyr/engine'
 import { SceneServiceDescriptor } from '../descriptor'
 import { NodeActor, SceneServiceActor } from '../actor'
 import { PickupNode } from './NodeInterpreter'
@@ -11,7 +11,7 @@ class SceneServiceInterpreter extends ServiceInterpreter {
     static direcation = new Vector2()
 
     private _unlisten = -1
-    protected createActor(descriptor: SceneServiceDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: SceneServiceDescriptor) {
         const actor = new SceneServiceActor(descriptor.uuid)
         return actor
     }
@@ -24,15 +24,15 @@ class SceneServiceInterpreter extends ServiceInterpreter {
     }
     protected resize = () => {
         const descriptor = Descriptor.get<Descriptor>(this.unit.uuid)
-        const actor = this.getActor<SceneServiceActor>(descriptor, { delta: 0 })
+        const actor = this.getActor<SceneServiceActor>(descriptor)
         this.setSize(actor)
     }
 
-    update(descriptor: SceneServiceDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
+    update(descriptor: SceneServiceDescriptor) {
+        super.update(descriptor)
 
-        const actor = this.getActor<SceneServiceActor>(descriptor, args)
-        actor.update(descriptor, args)
+        const actor = this.getActor<SceneServiceActor>(descriptor)
+        actor.update(descriptor)
 
         this.resize()
         actor.pipeline.shadowMap.enabled = descriptor.shadowMap
@@ -42,53 +42,53 @@ class SceneServiceInterpreter extends ServiceInterpreter {
         actor.pipeline.shadowMap.needsUpdate = true
     }
 
-    mount(descriptor: SceneServiceDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
+    mount(descriptor: SceneServiceDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor,  parentInterpreter, parentDescriptor)
 
-        const actor = this.getActor<SceneServiceActor>(descriptor, args)
+        const actor = this.getActor<SceneServiceActor>(descriptor)
         actor.clearStyleClass(actor.pipeline.domElement)
 
-        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor, args)
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor)
         if (parenActor instanceof HTMLActor) parenActor.add(actor)
 
         this._unlisten = this.graphics.engine.inputSystem.listen('resize', this.resize, { target: window })
     }
 
-    unmount(descriptor: SceneServiceDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        const actor = this.getActor<SceneServiceActor>(descriptor, args)
+    unmount(descriptor: SceneServiceDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<SceneServiceActor>(descriptor)
 
-        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor, args)
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor)
         parenActor.remove(actor)
 
         this.graphics.engine.inputSystem.unlisten(this._unlisten)
         this.resize()
 
-        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+        super.unmount(descriptor,  parentInterpreter, parentDescriptor)
     }
 
-    free(descriptor: SceneServiceDescriptor, args: UpdateArgs) {
-        const actor = this.getActor<SceneServiceActor>(descriptor, args)
+    free(descriptor: SceneServiceDescriptor) {
+        const actor = this.getActor<SceneServiceActor>(descriptor)
         actor.dispose()
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 
-    clear(service: ServiceDescriptor, args: UpdateArgs): void {
-        const actor = this.getActor<SceneServiceActor>(service, args)
+    clear(service: ServiceDescriptor): void {
+        const actor = this.getActor<SceneServiceActor>(service)
         actor.pipeline.clear()
     }
 
-    beforeRender(service: SceneServiceDescriptor, args: UpdateArgs) {
-        const actor = this.getActor<SceneServiceActor>(service, args)
+    beforeRender(service: SceneServiceDescriptor) {
+        const actor = this.getActor<SceneServiceActor>(service)
         actor.scene.updateMatrixWorld()
     }
 
-    render(service: SceneServiceDescriptor, args: UpdateArgs) {
+    render(service: SceneServiceDescriptor) {
         const cameraDescriptor = CameraDescriptor.get<CameraDescriptor>(this.graphics.scheduler.camera)
         if (cameraDescriptor === null) return
-        const actor = this.getActor<SceneServiceActor>(service, args)
+        const actor = this.getActor<SceneServiceActor>(service)
 
         const cameraInterpreter = this.graphics.getInterpreter(cameraDescriptor)
-        const camera = cameraInterpreter.getActor<NodeActor<Camera>>(cameraDescriptor, args)
+        const camera = cameraInterpreter.getActor<NodeActor<Camera>>(cameraDescriptor)
         if (camera.object instanceof PerspectiveCamera) {
             const aspect = actor.pipeline.domElement.clientWidth / actor.pipeline.domElement.clientHeight
             if (aspect !== camera.object.aspect) {
@@ -97,12 +97,12 @@ class SceneServiceInterpreter extends ServiceInterpreter {
             }
         }
 
-        actor.render(service, camera, args)
+        actor.render(service, camera)
     }
 
-    beforePickup(mouse: { x: number; y: number }, rect: DOMRect, args: UpdateArgs) {
+    beforePickup(mouse: { x: number; y: number }, rect: DOMRect) {
         const currentCamera = SceneServiceDescriptor.get<CameraDescriptor>(this.graphics.scheduler.camera)
-        const camera = this.graphics.getInterpreter(currentCamera).getActor<NodeActor<Camera>>(currentCamera, args)
+        const camera = this.graphics.getInterpreter(currentCamera).getActor<NodeActor<Camera>>(currentCamera)
 
         SceneServiceInterpreter.direcation.x = (mouse.x / rect.width) * 2 - 1
         SceneServiceInterpreter.direcation.y = -(mouse.y / rect.height) * 2 + 1

package/src/interpreter/ServiceSchedulerInterpreter.ts

@@ -1,21 +1,21 @@
 import { AnimationMixer, Object3D } from 'three'
-import { ServiceSchedulerInterpreter as SchedulerInterpreter, ServiceSchedulerDescriptor, UpdateArgs } from '@vyr/engine'
+import { ServiceSchedulerInterpreter as SchedulerInterpreter, ServiceSchedulerDescriptor, TickArgs } from '@vyr/engine'
 
 class ServiceSchedulerInterpreter extends SchedulerInterpreter {
     readonly mixer = new AnimationMixer(new Object3D())
 
-    updateMixer = (args: UpdateArgs) => {
+    updateMixer = (args: TickArgs) => {
         this.mixer.update(args.delta)
     }
 
-    install(descriptor: ServiceSchedulerDescriptor, args: UpdateArgs) {
-        super.install(descriptor, args)
+    install(descriptor: ServiceSchedulerDescriptor) {
+        super.install(descriptor)
         this.graphics.engine.listen('beforeRender', this.updateMixer)
     }
 
-    uninstall(descriptor: ServiceSchedulerDescriptor, args: UpdateArgs) {
+    uninstall(descriptor: ServiceSchedulerDescriptor) {
         this.graphics.engine.unlisten('beforeRender', this.updateMixer)
-        super.uninstall(descriptor, args)
+        super.uninstall(descriptor)
     }
 }
 SchedulerInterpreter.register(ServiceSchedulerInterpreter)

package/src/interpreter/SpriteInterpreter.ts

@@ -1,5 +1,5 @@
 import { Sprite, SpriteMaterial } from "three";
-import { Asset, UpdateArgs } from "@vyr/engine";
+import { Asset } from "@vyr/engine";
 import { SpriteDescriptor } from "../descriptor";
 import { NodeInterpreter } from "./NodeInterpreter";
 import { MaterialActor, NodeActor } from "../actor";
@@ -16,28 +16,28 @@ class SpriteInterpreter extends NodeInterpreter {
 
     static type = SpriteDescriptor.type
     
-    protected createActor(descriptor: SpriteDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: SpriteDescriptor) {
         const actor = new NodeActor(new Sprite())
         return actor
     }
 
-    useMaterial(material: string, args: UpdateArgs) {
+    useMaterial(material: string) {
         const materialDescriptor = Asset.get(material)
         if (materialDescriptor === null) return SpriteInterpreter.material
 
         const interpreter = this.graphics.getInterpreter(materialDescriptor)
-        const actor = interpreter.getActor<MaterialActor>(materialDescriptor, args)
+        const actor = interpreter.getActor<MaterialActor>(materialDescriptor)
         return actor.object instanceof SpriteMaterial ? actor.object : SpriteInterpreter.material
     }
 
-    getMaterial(descriptor: SpriteDescriptor, args: UpdateArgs) {
-        return this.useMaterial(descriptor.material, args)
+    getMaterial(descriptor: SpriteDescriptor) {
+        return this.useMaterial(descriptor.material)
     }
 
-    update(descriptor: SpriteDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<NodeActor<Sprite>>(descriptor, args)
-        actor.object.material = this.getMaterial(descriptor, args)
+    update(descriptor: SpriteDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<NodeActor<Sprite>>(descriptor)
+        actor.object.material = this.getMaterial(descriptor)
     }
 }
 NodeInterpreter.register(SpriteInterpreter)