@vyr/three 0.0.33 → 0.0.35

package/src/interpreter/OrbitControllerInterpreter.ts

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

package/src/interpreter/OrthographicCameraInterpreter.ts

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

package/src/interpreter/ParticleInterpreter.ts

@@ -13,14 +13,14 @@ import {
   CatmullRomCurve3,
   Vector3,
 } from "three";
-import { DatasetDescriptor, TickArgs } from "@vyr/engine";
-import { ParticleDescriptor } from "../descriptor";
+import { Store, TickArgs } from "@vyr/engine";
+import { Particle } from "../descriptor";
 import { NodeInterpreter } from "./NodeInterpreter";
 import { NodeActor } from "../actor";
 import { randomRange, texture } from "../utils";
 
-class ParticleInterpreter extends NodeInterpreter {
-  static type = ParticleDescriptor.type;
+export class ParticleInterpreter extends NodeInterpreter {
+  static type = Particle.type;
 
   private _duration = 0;
   private _geometry = new BufferGeometry();
@@ -29,7 +29,7 @@ class ParticleInterpreter extends NodeInterpreter {
   private _trackTexture = { value: new DataTexture() };
   uptime = 0;
 
-  protected createActor(descriptor: ParticleDescriptor) {
+  protected createActor(descriptor: Particle) {
     const actor = new NodeActor(new Points(this._geometry, this._material));
     return actor;
   }
@@ -112,10 +112,10 @@ class ParticleInterpreter extends NodeInterpreter {
       'gl_PointSize = vSize * size;'
     );
   }
-  private _setTrackMap(descriptor: ParticleDescriptor) {
+  private _setTrackMap(descriptor: Particle) {
     this.clear();
 
-    const trackData = DatasetDescriptor.getCollection<number[]>(descriptor.track);
+    const trackData = Store.getCollection<number[]>(descriptor.track);
     const count = Math.ceil(trackData.length / 512) * 512;
     const typeArray = this._createTypeArray(trackData, count);
     this._trackTexture.value = new DataTexture(typeArray, count, 1, RGBAFormat, FloatType);
@@ -133,7 +133,7 @@ class ParticleInterpreter extends NodeInterpreter {
     };
     this.graphics.engine.listen("beforeRender", this._updateRadio);
   }
-  private _updateMaterial(descriptor: ParticleDescriptor) {
+  private _updateMaterial(descriptor: Particle) {
     this._setTrackMap(descriptor);
     texture.setMap(this._material, "map", descriptor, this.graphics);
     texture.setMap(this._material, "alphaMap", descriptor, this.graphics);
@@ -141,7 +141,7 @@ class ParticleInterpreter extends NodeInterpreter {
     this._material.transparent = descriptor.transparent;
     this._material.colorWrite = descriptor.colorWrite;
     this._material.depthTest = descriptor.depthTest;
-    this._material.depthWrite = descriptor.depthrWrite;
+    this._material.depthWrite = descriptor.depthWrite;
     //@ts-ignore
     this._material.side = descriptor.side
     //@ts-ignore
@@ -149,14 +149,14 @@ class ParticleInterpreter extends NodeInterpreter {
     //@ts-ignore
     this._material.blending = descriptor.blending
     this._material.vertexColors = descriptor.vertexColors;
-    this._material.color.setStyle(descriptor.color.value);
-    this._material.opacity = descriptor.color.opacity;
+    this._material.color.setStyle(descriptor.color);
+    this._material.opacity = descriptor.opacity;
     this._material.size = 1;
     this._material.sizeAttenuation = descriptor.sizeAttenuation;
     this._material.fog = descriptor.fog;
     this._material.needsUpdate = true;
   }
-  private _updateGeometry(descriptor: ParticleDescriptor) {
+  private _updateGeometry(descriptor: Particle) {
     const positions: number[] = [];
     const offsets: number[] = [];
     const rotations: number[] = [];
@@ -199,7 +199,7 @@ class ParticleInterpreter extends NodeInterpreter {
     this._tracRadio.value = currentTime / this._duration;
   };
 
-  update(descriptor: ParticleDescriptor) {
+  update(descriptor: Particle) {
     super.update(descriptor);
     this._duration = descriptor.duration;
     this._updateGeometry(descriptor);
@@ -211,11 +211,9 @@ class ParticleInterpreter extends NodeInterpreter {
     this._trackTexture.value.dispose();
   }
 
-  free(descriptor: ParticleDescriptor) {
+  free(descriptor: Particle) {
     this.clear();
     super.free(descriptor);
   }
 }
-NodeInterpreter.register(ParticleInterpreter);
-
-export { ParticleInterpreter };
+NodeInterpreter.register(ParticleInterpreter);

package/src/interpreter/PerspectiveCameraInterpreter.ts

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

package/src/interpreter/PointsInterpreter.ts

@@ -1,10 +1,10 @@
-import { BufferGeometry, Points, Material, PointsMaterial } from "three";
+import { BufferGeometry, Points as ThreePoints, Material, PointsMaterial } from "three";
 import { Asset } from "@vyr/engine";
-import { PointsDescriptor } from "../descriptor";
+import { Points } from "../descriptor";
 import { NodeInterpreter } from "./NodeInterpreter";
 import { GeometryActor, MaterialActor, NodeActor } from "../actor";
 
-class PointsInterpreter extends NodeInterpreter {
+export class PointsInterpreter extends NodeInterpreter {
     private static _geometry: BufferGeometry | null = null
     private static _material: Material | null = null
     static get geometry() {
@@ -20,14 +20,14 @@ class PointsInterpreter extends NodeInterpreter {
         return this._material
     }
 
-    static type = PointsDescriptor.type
+    static type = Points.type
     
-    protected createActor(descriptor: PointsDescriptor) {
-        const actor = new NodeActor(new Points())
+    protected createActor(descriptor: Points) {
+        const actor = new NodeActor(new ThreePoints())
         return actor
     }
 
-    getGeometry(descriptor: PointsDescriptor) {
+    getGeometry(descriptor: Points) {
         const geometryDescriptor = Asset.get(descriptor.geometry)
         if (geometryDescriptor === null) return PointsInterpreter.geometry
 
@@ -45,17 +45,15 @@ class PointsInterpreter extends NodeInterpreter {
         return actor.object instanceof Material ? actor.object : PointsInterpreter.material
     }
 
-    getMaterial(descriptor: PointsDescriptor) {
+    getMaterial(descriptor: Points) {
         return this.useMaterial(descriptor.material)
     }
 
-    update(descriptor: PointsDescriptor) {
+    update(descriptor: Points) {
         super.update(descriptor)
-        const actor = this.getActor<NodeActor<Points>>(descriptor)
+        const actor = this.getActor<NodeActor<ThreePoints>>(descriptor)
         actor.object.geometry = this.getGeometry(descriptor)
         actor.object.material = this.getMaterial(descriptor)
     }
 }
-NodeInterpreter.register(PointsInterpreter)
-
-export { PointsInterpreter }
+NodeInterpreter.register(PointsInterpreter)

package/src/interpreter/Scene3DServiceInterpreter.ts

@@ -0,0 +1,118 @@
+import { PerspectiveCamera as ThreePerspectiveCamera, Raycaster, Vector2, Camera as ThreeCamera } from 'three'
+import { Camera as EngineCamera, Descriptor, HTMLActor, Interpreter, Service, ServiceInterpreter } from '@vyr/engine'
+import { Scene3DService } from '../descriptor'
+import { NodeActor, Scene3DServiceActor } from '../actor'
+import { PickupNode } from './NodeInterpreter'
+
+export class Scene3DServiceInterpreter extends Interpreter implements ServiceInterpreter {
+    static type = Scene3DService.type
+
+    static ray = new Raycaster()
+    static direcation = new Vector2()
+
+    private _unlisten = -1
+    protected createActor(descriptor: Scene3DService) {
+        const actor = new Scene3DServiceActor(descriptor.uuid)
+        return actor
+    }
+
+    protected setSize(actor: Scene3DServiceActor) {
+        const rect = actor.pipeline.domElement.getBoundingClientRect()
+        actor.pipeline.setSize(rect.width, rect.height)
+        actor.screenPipeline.setSize(rect.width, rect.height)
+        return rect
+    }
+    protected resize = () => {
+        const descriptor = Descriptor.get<Descriptor>(this.unit.uuid)
+        const actor = this.getActor<Scene3DServiceActor>(descriptor)
+        this.setSize(actor)
+    }
+
+    update(descriptor: Scene3DService) {
+        super.update(descriptor)
+
+        const actor = this.getActor<Scene3DServiceActor>(descriptor)
+        actor.update(descriptor)
+
+        this.resize()
+        actor.pipeline.shadowMap.enabled = descriptor.shadowMap
+        actor.pipeline.shadowMap.autoUpdate = descriptor.autoUpdateShadowMap
+        //@ts-ignore
+        actor.pipeline.shadowMap.type = descriptor.shadowMapType
+        actor.pipeline.shadowMap.needsUpdate = true
+    }
+
+    mount(descriptor: Scene3DService, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, parentInterpreter, parentDescriptor)
+
+        const actor = this.getActor<Scene3DServiceActor>(descriptor)
+
+        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: Scene3DService, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<Scene3DServiceActor>(descriptor)
+
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor)
+        parenActor.remove(actor)
+
+        this.graphics.engine.inputSystem.unlisten(this._unlisten)
+        this.resize()
+
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
+    }
+
+    free(descriptor: Scene3DService) {
+        const actor = this.getActor<Scene3DServiceActor>(descriptor)
+        actor.dispose()
+        super.free(descriptor)
+    }
+
+    clear(service: Service): void {
+        const actor = this.getActor<Scene3DServiceActor>(service)
+        actor.pipeline.clear()
+    }
+
+    beforeRender(service: Scene3DService) {
+        const actor = this.getActor<Scene3DServiceActor>(service)
+        actor.scene.updateMatrixWorld()
+    }
+
+    render(service: Scene3DService) {
+        const cameraDescriptor = Descriptor.get<EngineCamera>(this.graphics.scene.camera)
+        if (cameraDescriptor === null) return
+        const actor = this.getActor<Scene3DServiceActor>(service)
+
+        const cameraInterpreter = this.graphics.getInterpreter(cameraDescriptor)
+        const camera = cameraInterpreter.getActor<NodeActor<ThreeCamera>>(cameraDescriptor)
+        if (camera.object instanceof ThreePerspectiveCamera) {
+            const aspect = actor.pipeline.domElement.clientWidth / actor.pipeline.domElement.clientHeight
+            if (aspect !== camera.object.aspect) {
+                camera.object.aspect = aspect
+                camera.object.updateProjectionMatrix()
+            }
+        }
+
+        actor.render(service, camera)
+    }
+
+    afterRender(service: Service) { }
+
+    beforePickup(mouse: { x: number; y: number }, rect: DOMRect) {
+        const currentCamera = Descriptor.get<EngineCamera>(this.graphics.scene.camera)
+        const camera = this.graphics.getInterpreter(currentCamera).getActor<NodeActor<ThreeCamera>>(currentCamera)
+
+        Scene3DServiceInterpreter.direcation.x = (mouse.x / rect.width) * 2 - 1
+        Scene3DServiceInterpreter.direcation.y = -(mouse.y / rect.height) * 2 + 1
+
+        Scene3DServiceInterpreter.ray.setFromCamera(Scene3DServiceInterpreter.direcation, camera.object)
+    }
+
+    orderBy(result: PickupNode[]) {
+        result.sort((a, b) => a.minDistance - b.minDistance)
+    }
+}
+Interpreter.register(Scene3DServiceInterpreter)

package/src/interpreter/{ServiceSchedulerInterpreter.ts → SceneInterpreter.ts}

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

package/src/interpreter/SpriteInterpreter.ts

@@ -1,10 +1,10 @@
-import { Sprite, SpriteMaterial } from "three";
+import { Sprite as ThreeSprite, SpriteMaterial } from "three";
 import { Asset } from "@vyr/engine";
-import { SpriteDescriptor } from "../descriptor";
+import { Sprite } from "../descriptor";
 import { NodeInterpreter } from "./NodeInterpreter";
 import { MaterialActor, NodeActor } from "../actor";
 
-class SpriteInterpreter extends NodeInterpreter {
+export class SpriteInterpreter extends NodeInterpreter {
     private static _material: SpriteMaterial | null = null
 
     static get material() {
@@ -14,10 +14,10 @@ class SpriteInterpreter extends NodeInterpreter {
         return this._material
     }
 
-    static type = SpriteDescriptor.type
+    static type = Sprite.type
     
-    protected createActor(descriptor: SpriteDescriptor) {
-        const actor = new NodeActor(new Sprite())
+    protected createActor(descriptor: Sprite) {
+        const actor = new NodeActor(new ThreeSprite())
         return actor
     }
 
@@ -30,16 +30,14 @@ class SpriteInterpreter extends NodeInterpreter {
         return actor.object instanceof SpriteMaterial ? actor.object : SpriteInterpreter.material
     }
 
-    getMaterial(descriptor: SpriteDescriptor) {
+    getMaterial(descriptor: Sprite) {
         return this.useMaterial(descriptor.material)
     }
 
-    update(descriptor: SpriteDescriptor) {
+    update(descriptor: Sprite) {
         super.update(descriptor)
-        const actor = this.getActor<NodeActor<Sprite>>(descriptor)
+        const actor = this.getActor<NodeActor<ThreeSprite>>(descriptor)
         actor.object.material = this.getMaterial(descriptor)
     }
 }
-NodeInterpreter.register(SpriteInterpreter)
-
-export { SpriteInterpreter }
+NodeInterpreter.register(SpriteInterpreter)

package/src/interpreter/{TextInterpreter.ts → Text3DInterpreter.ts}

@@ -1,17 +1,17 @@
 import { BufferGeometry, Mesh } from "three";
 import { Font } from 'three/examples/jsm/loaders/FontLoader.js'
 import { Asset } from "@vyr/engine";
-import { TextDescriptor } from "../descriptor";
+import { Text3D } from "../descriptor";
 import { NodeInterpreter } from "./NodeInterpreter";
 import { NodeActor } from "../actor";
 import { geometry, TextUtils, material } from "../utils";
 
-class TextInterpreter extends NodeInterpreter {
-    static type = TextDescriptor.type
+export class Text3DInterpreter extends NodeInterpreter {
+    static type = Text3D.type
     private _geometry = new BufferGeometry()
     private _cacheKey = ''
 
-    protected createActor(descriptor: TextDescriptor) {
+    protected createActor(descriptor: Text3D) {
         const actor = new NodeActor(new Mesh(this._geometry, material.defaultMaterial()))
         return actor
     }
@@ -30,11 +30,11 @@ class TextInterpreter extends NodeInterpreter {
         return ((hash1 >>> 0) ^ (hash2 >>> 0)) >>> 0;
     }
 
-    getCacheKey(descriptor: TextDescriptor) {
+    getCacheKey(descriptor: Text3D) {
         return `${this._fastHash(descriptor.text)}_${descriptor.size}_${descriptor.lineHeight}_${descriptor.maxWidth}_${descriptor.letterSpacing}`
     }
 
-    setAttribute(descriptor: TextDescriptor) {
+    setAttribute(descriptor: Text3D) {
         const font = Asset.get<Font>(descriptor.font)
         if (font instanceof Font) {
             const options = {
@@ -55,7 +55,7 @@ class TextInterpreter extends NodeInterpreter {
         if (descriptor.flattenUVsToPlane) geometry.flattenUVsToPlane(this._geometry)
     }
 
-    update(descriptor: TextDescriptor) {
+    update(descriptor: Text3D) {
         super.update(descriptor)
         const actor = this.getActor<NodeActor<Mesh>>(descriptor)
         const cacheKey = this.getCacheKey(descriptor)
@@ -66,11 +66,9 @@ class TextInterpreter extends NodeInterpreter {
         actor.object.material = material.getMaterial(descriptor.material, this.graphics)
     }
 
-    free(descriptor: TextDescriptor) {
+    free(descriptor: Text3D) {
         this._geometry.dispose()
         super.free(descriptor)
     }
 }
-NodeInterpreter.register(TextInterpreter)
-
-export { TextInterpreter }
+NodeInterpreter.register(Text3DInterpreter)

package/src/interpreter/TransformControllerInterpreter.ts

@@ -1,29 +1,29 @@
 import { Descriptor, Interpreter } from "@vyr/engine";
-import { TransformControllerDescriptor } from '../descriptor'
+import { TransformController } from '../descriptor'
 import { NodeActor, TransformControllerActor } from "../actor"
 
-class TransformControllerInterpreter extends Interpreter {
-  static type = TransformControllerDescriptor.type
+export class TransformControllerInterpreter extends Interpreter {
+  static type = TransformController.type
 
-  protected createActor(descriptor: TransformControllerDescriptor) {
+  protected createActor(descriptor: TransformController) {
     const actor = new TransformControllerActor()
     return actor
   }
 
-  update(descriptor: TransformControllerDescriptor) {
+  update(descriptor: TransformController) {
     super.update(descriptor)
     const actor = this.getActor<TransformControllerActor>(descriptor)
     actor.update(descriptor, this.graphics)
   }
 
-  mount(descriptor: TransformControllerDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+  mount(descriptor: TransformController, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
     super.mount(descriptor,  parentInterpreter, parentDescriptor)
     const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor)
     const actor = this.getActor<TransformControllerActor>(descriptor)
     parenActor.add(actor)
   }
 
-  unmount(descriptor: TransformControllerDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+  unmount(descriptor: TransformController, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
     const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor)
     const actor = this.getActor<TransformControllerActor>(descriptor)
     parenActor.remove(actor)
@@ -32,13 +32,10 @@ class TransformControllerInterpreter extends Interpreter {
     super.unmount(descriptor,  parentInterpreter, parentDescriptor)
   }
 
-  free(descriptor: TransformControllerDescriptor) {
+  free(descriptor: TransformController) {
     const actor = this.getActor<TransformControllerActor>(descriptor)
     actor.dispose(this.graphics)
     super.free(descriptor)
   }
 }
-Interpreter.register(TransformControllerInterpreter)
-
-
-export { TransformControllerInterpreter }
+Interpreter.register(TransformControllerInterpreter)

package/src/interpreter/animation/AnimationActionInterpreter.ts

@@ -1,12 +1,12 @@
-import { AnimationAction, AnimationMixer } from 'three'
+import { AnimationAction as ThreeAnimationAction, AnimationMixer } from 'three'
 import { Descriptor, Interpreter } from "@vyr/engine"
-import { AnimationActionDescriptor, ModelDescriptor } from "../../descriptor"
+import { AnimationAction, Model } from "../../descriptor"
 import { ModelInterpreter } from '../ModelInterpreter'
-import { ServiceSchedulerInterpreter } from '../ServiceSchedulerInterpreter'
+import { SceneInterpreter } from '../SceneInterpreter'
 
-class AnimationActionInterpreter extends Interpreter {
-    static type = AnimationActionDescriptor.type
-    animationAction: AnimationAction | null = null
+export class AnimationActionInterpreter extends Interpreter {
+    static type = AnimationAction.type
+    animationAction: ThreeAnimationAction | null = null
 
     freeAction(mixer: AnimationMixer) {
         if (this.animationAction) {
@@ -17,7 +17,7 @@ class AnimationActionInterpreter extends Interpreter {
         }
     }
 
-    setProperty(action: AnimationAction, descriptor: AnimationActionDescriptor) {
+    setProperty(action: ThreeAnimationAction, descriptor: AnimationAction) {
         action.enabled = descriptor.enabled
         action.timeScale = descriptor.timeScale
         action.weight = descriptor.weight
@@ -29,12 +29,12 @@ class AnimationActionInterpreter extends Interpreter {
         descriptor.play ? action.play() : action.stop()
     }
 
-    update(descriptor: AnimationActionDescriptor) {
+    update(descriptor: AnimationAction) {
         super.update(descriptor)
-        const scheduler = this.graphics.getInterpreter<ServiceSchedulerInterpreter>(this.graphics.scheduler)
-        this.freeAction(scheduler.mixer)
+        const scene = this.graphics.getInterpreter<SceneInterpreter>(this.graphics.scene)
+        this.freeAction(scene.mixer)
 
-        const parentDescriptor = ModelDescriptor.get<ModelDescriptor>(this.unit.parent)
+        const parentDescriptor = Model.get<Model>(this.unit.parent)
         const parentInterpreter = this.graphics.getInterpreter<ModelInterpreter>(parentDescriptor)
 
         if (parentInterpreter instanceof ModelInterpreter) {
@@ -42,7 +42,7 @@ class AnimationActionInterpreter extends Interpreter {
             if (model === undefined) return
             for (const clip of model.animations) {
                 if (clip.name === descriptor.clip) {
-                    this.animationAction = scheduler.mixer.clipAction(clip, model)
+                    this.animationAction = scene.mixer.clipAction(clip, model)
                     this.animationAction.clampWhenFinished = true
                     this.setProperty(this.animationAction, descriptor)
                 }
@@ -50,17 +50,15 @@ class AnimationActionInterpreter extends Interpreter {
         }
     }
 
-    mount(descriptor: AnimationActionDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+    mount(descriptor: AnimationAction, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
         super.mount(descriptor,  parentInterpreter, parentDescriptor)
         this.getActor(descriptor)
     }
 
-    unmount(descriptor: AnimationActionDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        const scheduler = this.graphics.getInterpreter<ServiceSchedulerInterpreter>(this.graphics.scheduler)
-        this.freeAction(scheduler.mixer)
+    unmount(descriptor: AnimationAction, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const scene = this.graphics.getInterpreter<SceneInterpreter>(this.graphics.scene)
+        this.freeAction(scene.mixer)
         super.unmount(descriptor,  parentInterpreter, parentDescriptor)
     }
 }
-Interpreter.register(AnimationActionInterpreter)
-
-export { AnimationActionInterpreter }
+Interpreter.register(AnimationActionInterpreter)