@vyr/three 0.0.33 → 0.0.35

package/src/interpreter/geometry/BoxGeometryInterpreter.ts

@@ -1,34 +1,32 @@
-import { BufferGeometry, BoxGeometry } from "three";
+import { BufferGeometry, BoxGeometry as ThreeBoxGeometry } from "three";
 import { Interpreter } from "@vyr/engine";
-import { BoxGeometryDescriptor } from "../../descriptor";
+import { BoxGeometry } from "../../descriptor";
 import { GeometryActor } from "../../actor";
 
-class BoxGeometryInterpreter extends Interpreter {
-    static type = BoxGeometryDescriptor.type
+export class BoxGeometryInterpreter extends Interpreter {
+    static type = BoxGeometry.type
 
-    protected createActor(descriptor: BoxGeometryDescriptor) {
+    protected createActor(descriptor: BoxGeometry) {
         const actor = new GeometryActor(new BufferGeometry())
         return actor
     }
 
-    setAttribute(actor: GeometryActor<BoxGeometry>, descriptor: BoxGeometryDescriptor) {
-        const source = new BoxGeometry(descriptor.width, descriptor.height, descriptor.depth, descriptor.widthSegments, descriptor.heightSegments, descriptor.depthSegments)
+    setAttribute(actor: GeometryActor<BufferGeometry>, descriptor: BoxGeometry) {
+        const source = new ThreeBoxGeometry(descriptor.width, descriptor.height, descriptor.depth, descriptor.widthSegments, descriptor.heightSegments, descriptor.depthSegments)
         actor.object.copy(source)
         source.dispose()
     }
 
-    update(descriptor: BoxGeometryDescriptor) {
+    update(descriptor: BoxGeometry) {
         super.update(descriptor)
-        const actor = this.getActor<GeometryActor<BoxGeometry>>(descriptor)
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         this.setAttribute(actor, descriptor)
     }
 
-    free(descriptor: BoxGeometryDescriptor) {
-        const actor = this.getActor<GeometryActor<BoxGeometry>>(descriptor)
+    free(descriptor: BoxGeometry) {
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 }
-Interpreter.register(BoxGeometryInterpreter)
-
-export { BoxGeometryInterpreter }
+Interpreter.register(BoxGeometryInterpreter)

package/src/interpreter/geometry/BufferGeometryInterpreter.ts

@@ -1,11 +1,11 @@
-import { BufferGeometry, BufferGeometryLoader } from "three";
-import { DatasetDescriptor, Interpreter } from "@vyr/engine";
-import { BufferGeometryDescriptor } from "../../descriptor";
+import { BufferGeometry as ThreeBufferGeometry, BufferGeometryLoader } from "three";
+import { Store, Interpreter } from "@vyr/engine";
+import { BufferGeometry } from "../../descriptor";
 import { GeometryActor } from "../../actor";
 
 let _loader: BufferGeometryLoader | null = null
-class BufferGeometryInterpreter extends Interpreter {
-    static type = BufferGeometryDescriptor.type
+export class BufferGeometryInterpreter extends Interpreter {
+    static type = BufferGeometry.type
     static get loader() {
         if (_loader === null) {
             _loader = new BufferGeometryLoader()
@@ -13,16 +13,16 @@ class BufferGeometryInterpreter extends Interpreter {
         return _loader
     }
 
-    protected createActor(descriptor: BufferGeometryDescriptor) {
-        const actor = new GeometryActor(new BufferGeometry())
+    protected createActor(descriptor: BufferGeometry) {
+        const actor = new GeometryActor(new ThreeBufferGeometry())
         return actor
     }
 
-    setAttribute(actor: GeometryActor<BufferGeometry>, descriptor: BufferGeometryDescriptor) {
-        const buffer = DatasetDescriptor.getData(descriptor.buffer)
+    setAttribute(actor: GeometryActor<ThreeBufferGeometry>, descriptor: BufferGeometry) {
+        const buffer = Store.getData(descriptor.buffer)
         let source
         if (buffer === null) {
-            source = new BufferGeometry()
+            source = new ThreeBufferGeometry()
         } else {
             source = BufferGeometryInterpreter.loader.parse(buffer)
         }
@@ -30,18 +30,16 @@ class BufferGeometryInterpreter extends Interpreter {
         source.dispose()
     }
 
-    update(descriptor: BufferGeometryDescriptor) {
+    update(descriptor: BufferGeometry) {
         super.update(descriptor)
-        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
+        const actor = this.getActor<GeometryActor<ThreeBufferGeometry>>(descriptor)
         this.setAttribute(actor, descriptor)
     }
 
-    free(descriptor: BufferGeometryDescriptor) {
-        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
+    free(descriptor: BufferGeometry) {
+        const actor = this.getActor<GeometryActor<ThreeBufferGeometry>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 }
-Interpreter.register(BufferGeometryInterpreter)
-
-export { BufferGeometryInterpreter }
+Interpreter.register(BufferGeometryInterpreter)

package/src/interpreter/geometry/CircleGeometryInterpreter.ts

@@ -1,34 +1,32 @@
-import { BufferGeometry, CircleGeometry } from "three";
+import { BufferGeometry, CircleGeometry as ThreeCircleGeometry } from "three";
 import { Interpreter } from "@vyr/engine";
-import { CircleGeometryDescriptor } from "../../descriptor";
+import { CircleGeometry } from "../../descriptor";
 import { GeometryActor } from "../../actor";
 
-class CircleGeometryInterpreter extends Interpreter {
-    static type = CircleGeometryDescriptor.type
+export class CircleGeometryInterpreter extends Interpreter {
+    static type = CircleGeometry.type
 
-    protected createActor(descriptor: CircleGeometryDescriptor) {
+    protected createActor(descriptor: CircleGeometry) {
         const actor = new GeometryActor(new BufferGeometry())
         return actor
     }
 
-    setAttribute(actor: GeometryActor<CircleGeometry>, descriptor: CircleGeometryDescriptor) {
-        const source = new CircleGeometry(descriptor.radius, descriptor.segments, descriptor.thetaStart, descriptor.thetaLength)
+    setAttribute(actor: GeometryActor<BufferGeometry>, descriptor: CircleGeometry) {
+        const source = new ThreeCircleGeometry(descriptor.radius, descriptor.segments, descriptor.thetaStart, descriptor.thetaLength)
         actor.object.copy(source)
         source.dispose()
     }
 
-    update(descriptor: CircleGeometryDescriptor) {
+    update(descriptor: CircleGeometry) {
         super.update(descriptor)
-        const actor = this.getActor<GeometryActor<CircleGeometry>>(descriptor)
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         this.setAttribute(actor, descriptor)
     }
 
-    free(descriptor: CircleGeometryDescriptor) {
-        const actor = this.getActor<GeometryActor<CircleGeometry>>(descriptor)
+    free(descriptor: CircleGeometry) {
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 }
-Interpreter.register(CircleGeometryInterpreter)
-
-export { CircleGeometryInterpreter }
+Interpreter.register(CircleGeometryInterpreter)

package/src/interpreter/geometry/CylinderGeometryInterpreter.ts

@@ -1,34 +1,32 @@
-import { BufferGeometry, CylinderGeometry } from "three";
+import { BufferGeometry, CylinderGeometry as ThreeCylinderGeometry } from "three";
 import { Interpreter } from "@vyr/engine";
-import { CylinderGeometryDescriptor } from "../../descriptor";
+import { CylinderGeometry } from "../../descriptor";
 import { GeometryActor } from "../../actor";
 
-class CylinderGeometryInterpreter extends Interpreter {
-    static type = CylinderGeometryDescriptor.type
+export class CylinderGeometryInterpreter extends Interpreter {
+    static type = CylinderGeometry.type
 
-    protected createActor(descriptor: CylinderGeometryDescriptor) {
+    protected createActor(descriptor: CylinderGeometry) {
         const actor = new GeometryActor(new BufferGeometry())
         return actor
     }
 
-    setAttribute(actor: GeometryActor<CylinderGeometry>, descriptor: CylinderGeometryDescriptor) {
-        const source = new CylinderGeometry(descriptor.radiusTop, descriptor.radiusBottom, descriptor.height, descriptor.radialSegments, descriptor.heightSegments, descriptor.openEnded, descriptor.thetaStart, descriptor.thetaLength)
+    setAttribute(actor: GeometryActor<BufferGeometry>, descriptor: CylinderGeometry) {
+        const source = new ThreeCylinderGeometry(descriptor.radiusTop, descriptor.radiusBottom, descriptor.height, descriptor.radialSegments, descriptor.heightSegments, descriptor.openEnded, descriptor.thetaStart, descriptor.thetaLength)
         actor.object.copy(source)
         source.dispose()
     }
 
-    update(descriptor: CylinderGeometryDescriptor) {
+    update(descriptor: CylinderGeometry) {
         super.update(descriptor)
-        const actor = this.getActor<GeometryActor<CylinderGeometry>>(descriptor)
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         this.setAttribute(actor, descriptor)
     }
 
-    free(descriptor: CylinderGeometryDescriptor) {
-        const actor = this.getActor<GeometryActor<CylinderGeometry>>(descriptor)
+    free(descriptor: CylinderGeometry) {
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 }
-Interpreter.register(CylinderGeometryInterpreter)
-
-export { CylinderGeometryInterpreter }
+Interpreter.register(CylinderGeometryInterpreter)

package/src/interpreter/geometry/ExtrudeGeometryInterpreter.ts

@@ -1,18 +1,18 @@
-import { BufferGeometry, ExtrudeGeometry, Path, Shape, } from "three";
-import { DatasetDescriptor, Interpreter, JsonAsset } from "@vyr/engine";
-import { ExtrudeGeometryDescriptor } from "../../descriptor";
+import { BufferGeometry, ExtrudeGeometry as ThreeExtrudeGeometry, Path, Shape, } from "three";
+import { Store, Interpreter, JsonAsset } from "@vyr/engine";
+import { ExtrudeGeometry } from "../../descriptor";
 import { GeometryActor } from "../../actor";
 import { geometry } from "../../utils";
 
-class ExtrudeGeometryInterpreter extends Interpreter {
-    static type = ExtrudeGeometryDescriptor.type
+export class ExtrudeGeometryInterpreter extends Interpreter {
+    static type = ExtrudeGeometry.type
 
-    protected createActor(descriptor: ExtrudeGeometryDescriptor) {
+    protected createActor(descriptor: ExtrudeGeometry) {
         const actor = new GeometryActor(new BufferGeometry())
         return actor
     }
 
-    createShapes(collection: JsonAsset[], shapes: Shape[], descriptor: ExtrudeGeometryDescriptor) {
+    createShapes(collection: JsonAsset[], shapes: Shape[], descriptor: ExtrudeGeometry) {
         for (const shapeData of collection) {
             const region = shapeData[0]
             const shape = new Shape(geometry.getPointsOfshapeData(region, descriptor.offset))
@@ -26,30 +26,28 @@ class ExtrudeGeometryInterpreter extends Interpreter {
         }
     }
 
-    setAttribute(actor: GeometryActor<ExtrudeGeometry>, descriptor: ExtrudeGeometryDescriptor) {
-        const collection = DatasetDescriptor.getCollection<JsonAsset>(descriptor.shapes)
+    setAttribute(actor: GeometryActor<BufferGeometry>, descriptor: ExtrudeGeometry) {
+        const collection = Store.getCollection<JsonAsset>(descriptor.shapes)
         const shapes: Shape[] = []
         this.createShapes(collection, shapes, descriptor)
 
-        const source = new ExtrudeGeometry(shapes, geometry.getExtrudeOptions(descriptor))
+        const source = new ThreeExtrudeGeometry(shapes, geometry.getExtrudeOptions(descriptor))
         actor.object.copy(source)
         source.dispose()
 
         if (descriptor.flattenUVsToPlane) geometry.flattenUVsToPlane(actor.object)
     }
 
-    update(descriptor: ExtrudeGeometryDescriptor) {
+    update(descriptor: ExtrudeGeometry) {
         super.update(descriptor)
-        const actor = this.getActor<GeometryActor<ExtrudeGeometry>>(descriptor)
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         this.setAttribute(actor, descriptor)
     }
 
-    free(descriptor: ExtrudeGeometryDescriptor) {
-        const actor = this.getActor<GeometryActor<ExtrudeGeometry>>(descriptor)
+    free(descriptor: ExtrudeGeometry) {
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 }
-Interpreter.register(ExtrudeGeometryInterpreter)
-
-export { ExtrudeGeometryInterpreter }
+Interpreter.register(ExtrudeGeometryInterpreter)

package/src/interpreter/geometry/PlaneGeometryInterpreter.ts

@@ -1,34 +1,32 @@
-import { BufferGeometry, PlaneGeometry } from "three";
+import { BufferGeometry, PlaneGeometry as ThreePlaneGeometry } from "three";
 import { Interpreter } from "@vyr/engine";
-import { PlaneGeometryDescriptor } from "../../descriptor";
+import { PlaneGeometry } from "../../descriptor";
 import { GeometryActor } from "../../actor";
 
-class PlaneGeometryInterpreter extends Interpreter {
-    static type = PlaneGeometryDescriptor.type
+export class PlaneGeometryInterpreter extends Interpreter {
+    static type = PlaneGeometry.type
 
-    protected createActor(descriptor: PlaneGeometryDescriptor) {
+    protected createActor(descriptor: PlaneGeometry) {
         const actor = new GeometryActor(new BufferGeometry())
         return actor
     }
 
-    setAttribute(actor: GeometryActor<PlaneGeometry>, descriptor: PlaneGeometryDescriptor) {
-        const source = new PlaneGeometry(descriptor.width, descriptor.height, descriptor.widthSegments, descriptor.heightSegments)
+    setAttribute(actor: GeometryActor<BufferGeometry>, descriptor: PlaneGeometry) {
+        const source = new ThreePlaneGeometry(descriptor.width, descriptor.height, descriptor.widthSegments, descriptor.heightSegments)
         actor.object.copy(source)
         source.dispose()
     }
 
-    update(descriptor: PlaneGeometryDescriptor) {
+    update(descriptor: PlaneGeometry) {
         super.update(descriptor)
-        const actor = this.getActor<GeometryActor<PlaneGeometry>>(descriptor)
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         this.setAttribute(actor, descriptor)
     }
 
-    free(descriptor: PlaneGeometryDescriptor) {
-        const actor = this.getActor<GeometryActor<PlaneGeometry>>(descriptor)
+    free(descriptor: PlaneGeometry) {
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 }
-Interpreter.register(PlaneGeometryInterpreter)
-
-export { PlaneGeometryInterpreter }
+Interpreter.register(PlaneGeometryInterpreter)

package/src/interpreter/geometry/RingGeometryInterpreter.ts

@@ -1,34 +1,32 @@
-import { BufferGeometry, RingGeometry } from "three";
+import { BufferGeometry, RingGeometry as ThreeRingGeometry } from "three";
 import { Interpreter } from "@vyr/engine";
-import { RingGeometryDescriptor } from "../../descriptor";
+import { RingGeometry } from "../../descriptor";
 import { GeometryActor } from "../../actor";
 
-class RingGeometryInterpreter extends Interpreter {
-    static type = RingGeometryDescriptor.type
+export class RingGeometryInterpreter extends Interpreter {
+    static type = RingGeometry.type
 
-    protected createActor(descriptor: RingGeometryDescriptor) {
+    protected createActor(descriptor: RingGeometry) {
         const actor = new GeometryActor(new BufferGeometry())
         return actor
     }
 
-    setAttribute(actor: GeometryActor<RingGeometry>, descriptor: RingGeometryDescriptor) {
-        const source = new RingGeometry(descriptor.innerRadius, descriptor.outerRadius, descriptor.thetaSegments, descriptor.phiSegments, descriptor.thetaStart, descriptor.thetaLength)
+    setAttribute(actor: GeometryActor<BufferGeometry>, descriptor: RingGeometry) {
+        const source = new ThreeRingGeometry(descriptor.innerRadius, descriptor.outerRadius, descriptor.thetaSegments, descriptor.phiSegments, descriptor.thetaStart, descriptor.thetaLength)
         actor.object.copy(source)
         source.dispose()
     }
 
-    update(descriptor: RingGeometryDescriptor) {
+    update(descriptor: RingGeometry) {
         super.update(descriptor)
-        const actor = this.getActor<GeometryActor<RingGeometry>>(descriptor)
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         this.setAttribute(actor, descriptor)
     }
 
-    free(descriptor: RingGeometryDescriptor) {
-        const actor = this.getActor<GeometryActor<RingGeometry>>(descriptor)
+    free(descriptor: RingGeometry) {
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 }
-Interpreter.register(RingGeometryInterpreter)
-
-export { RingGeometryInterpreter }
+Interpreter.register(RingGeometryInterpreter)

package/src/interpreter/geometry/SphereGeometryInterpreter.ts

@@ -1,34 +1,32 @@
-import { BufferGeometry, SphereGeometry } from "three";
+import { BufferGeometry, SphereGeometry as ThreeSphereGeometry } from "three";
 import { Interpreter } from "@vyr/engine";
-import { SphereGeometryDescriptor } from "../../descriptor";
+import { SphereGeometry } from "../../descriptor";
 import { GeometryActor } from "../../actor";
 
-class SphereGeometryInterpreter extends Interpreter {
-    static type = SphereGeometryDescriptor.type
+export class SphereGeometryInterpreter extends Interpreter {
+    static type = SphereGeometry.type
 
-    protected createActor(descriptor: SphereGeometryDescriptor) {
+    protected createActor(descriptor: SphereGeometry) {
         const actor = new GeometryActor(new BufferGeometry())
         return actor
     }
 
-    setAttribute(actor: GeometryActor<SphereGeometry>, descriptor: SphereGeometryDescriptor) {
-        const source = new SphereGeometry(descriptor.radius, descriptor.widthSegments, descriptor.heightSegments, descriptor.phiStart, descriptor.phiLength, descriptor.thetaStart, descriptor.thetaLength)
+    setAttribute(actor: GeometryActor<BufferGeometry>, descriptor: SphereGeometry) {
+        const source = new ThreeSphereGeometry(descriptor.radius, descriptor.widthSegments, descriptor.heightSegments, descriptor.phiStart, descriptor.phiLength, descriptor.thetaStart, descriptor.thetaLength)
         actor.object.copy(source)
         source.dispose()
     }
 
-    update(descriptor: SphereGeometryDescriptor) {
+    update(descriptor: SphereGeometry) {
         super.update(descriptor)
-        const actor = this.getActor<GeometryActor<SphereGeometry>>(descriptor)
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         this.setAttribute(actor, descriptor)
     }
 
-    free(descriptor: SphereGeometryDescriptor) {
-        const actor = this.getActor<GeometryActor<SphereGeometry>>(descriptor)
+    free(descriptor: SphereGeometry) {
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 }
-Interpreter.register(SphereGeometryInterpreter)
-
-export { SphereGeometryInterpreter }
+Interpreter.register(SphereGeometryInterpreter)

package/src/interpreter/geometry/SurfaceGeometryInterpreter.ts

@@ -1,10 +1,10 @@
-import { ExtrudeGeometry, Spherical, Vector3 } from "three";
-import { SurfaceGeometryDescriptor } from "../../descriptor";
+import { BufferGeometry, ExtrudeGeometry as ThreeExtrudeGeometry, Spherical, Vector2, Vector3 } from "three";
+import { SurfaceGeometry } from "../../descriptor";
 import { GeometryActor } from "../../actor";
 import { ExtrudeGeometryInterpreter } from "./ExtrudeGeometryInterpreter";
 
-class SurfaceGeometryInterpreter extends ExtrudeGeometryInterpreter {
-    static type = SurfaceGeometryDescriptor.type
+export class SurfaceGeometryInterpreter extends ExtrudeGeometryInterpreter {
+    static type = SurfaceGeometry.type
     /**
     * 经纬度转V3
     * @param lng 经度
@@ -19,7 +19,7 @@ class SurfaceGeometryInterpreter extends ExtrudeGeometryInterpreter {
         return new Vector3().setFromSpherical(new Spherical(radius, phi, theta))
     }
 
-    setAttribute(actor: GeometryActor<ExtrudeGeometry>, descriptor: SurfaceGeometryDescriptor) {
+    setAttribute(actor: GeometryActor<BufferGeometry>, descriptor: SurfaceGeometry) {
         super.setAttribute(actor, descriptor)
         const position = actor.object.getAttribute('position')
         for (let i = 0; i < position.count; i++) {
@@ -33,6 +33,4 @@ class SurfaceGeometryInterpreter extends ExtrudeGeometryInterpreter {
         actor.object.computeVertexNormals()
     }
 }
-ExtrudeGeometryInterpreter.register(SurfaceGeometryInterpreter)
-
-export { SurfaceGeometryInterpreter }
+ExtrudeGeometryInterpreter.register(SurfaceGeometryInterpreter)

package/src/interpreter/geometry/TubeGeometryInterpreter.ts

@@ -1,42 +1,40 @@
-import { BufferGeometry, CatmullRomCurve3, TubeGeometry, Vector3, } from "three";
-import { DatasetDescriptor, Interpreter, JsonAsset } from "@vyr/engine";
-import { TubeGeometryDescriptor } from "../../descriptor";
+import { BufferGeometry, CatmullRomCurve3, TubeGeometry as ThreeTubeGeometry, Vector3, } from "three";
+import { Store, Interpreter, JsonAsset } from "@vyr/engine";
+import { TubeGeometry } from "../../descriptor";
 import { GeometryActor } from "../../actor";
 import { geometry } from "../../utils";
 
-class TubeGeometryInterpreter extends Interpreter {
-    static type = TubeGeometryDescriptor.type
+export class TubeGeometryInterpreter extends Interpreter {
+    static type = TubeGeometry.type
 
-    protected createActor(descriptor: TubeGeometryDescriptor) {
+    protected createActor(descriptor: TubeGeometry) {
         const actor = new GeometryActor(new BufferGeometry())
         return actor
     }
 
-    createPath(line: JsonAsset, descriptor: TubeGeometryDescriptor) {
+    createPath(line: JsonAsset, descriptor: TubeGeometry) {
         const points = geometry.getPointsOfLineData(line, descriptor.offset)
         return new CatmullRomCurve3(points, false)
     }
 
-    setAttribute(actor: GeometryActor<TubeGeometry>, descriptor: TubeGeometryDescriptor) {
-        const data = DatasetDescriptor.getCollection<number[]>(descriptor.track)
+    setAttribute(actor: GeometryActor<BufferGeometry>, descriptor: TubeGeometry) {
+        const data = Store.getCollection<number[]>(descriptor.track)
         const path = data.length === 0 ? new CatmullRomCurve3([new Vector3(), new Vector3()]) : this.createPath(data, descriptor)
-        const source = new TubeGeometry(path, descriptor.tubularSegments, descriptor.radius, descriptor.radialSegments, descriptor.closed)
+        const source = new ThreeTubeGeometry(path, descriptor.tubularSegments, descriptor.radius, descriptor.radialSegments, descriptor.closed)
         actor.object.copy(source)
         source.dispose()
     }
 
-    update(descriptor: TubeGeometryDescriptor) {
+    update(descriptor: TubeGeometry) {
         super.update(descriptor)
-        const actor = this.getActor<GeometryActor<TubeGeometry>>(descriptor)
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         this.setAttribute(actor, descriptor)
     }
 
-    free(descriptor: TubeGeometryDescriptor) {
-        const actor = this.getActor<GeometryActor<TubeGeometry>>(descriptor)
+    free(descriptor: TubeGeometry) {
+        const actor = this.getActor<GeometryActor<BufferGeometry>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 }
-Interpreter.register(TubeGeometryInterpreter)
-
-export { TubeGeometryInterpreter }
+Interpreter.register(TubeGeometryInterpreter)

package/src/interpreter/helper/AxesHelperInterpreter.ts

@@ -1,17 +1,17 @@
-import { AxesHelper } from 'three'
-import { AxesHelperDescriptor } from "../../descriptor";
+import { AxesHelper as ThreeAxesHelper } from 'three'
+import { AxesHelper } from "../../descriptor";
 import { NodeInterpreter } from "../NodeInterpreter";
 import { NodeActor } from '../../actor';
 
-class AxesHelperInterpreter extends NodeInterpreter {
-    static type = AxesHelperDescriptor.type
+export class AxesHelperInterpreter extends NodeInterpreter {
+    static type = AxesHelper.type
 
-    protected createActor(descriptor: AxesHelperDescriptor) {
-        const actor = new NodeActor(new AxesHelper())
+    protected createActor(descriptor: AxesHelper) {
+        const actor = new NodeActor(new ThreeAxesHelper())
         return actor
     }
 
-    setAxesHelper(actor: NodeActor<AxesHelper>, descriptor: AxesHelperDescriptor) {
+    setAxesHelper(actor: NodeActor<ThreeAxesHelper>, descriptor: AxesHelper) {
         const size = 1000000
         actor.object.scale.set(size, size, size)
         if (Array.isArray(actor.object.material) === false) {
@@ -20,18 +20,16 @@ class AxesHelperInterpreter extends NodeInterpreter {
         }
     }
 
-    update(descriptor: AxesHelperDescriptor) {
+    update(descriptor: AxesHelper) {
         super.update(descriptor)
-        const actor = this.getActor<NodeActor<AxesHelper>>(descriptor)
+        const actor = this.getActor<NodeActor<ThreeAxesHelper>>(descriptor)
         this.setAxesHelper(actor, descriptor)
     }
 
-    free(descriptor: AxesHelperDescriptor) {
-        const actor = this.getActor<NodeActor<AxesHelper>>(descriptor)
+    free(descriptor: AxesHelper) {
+        const actor = this.getActor<NodeActor<ThreeAxesHelper>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 }
-NodeInterpreter.register(AxesHelperInterpreter)
-
-export { AxesHelperInterpreter }
+NodeInterpreter.register(AxesHelperInterpreter)

package/src/interpreter/index.ts

@@ -25,12 +25,12 @@ export * from "./light/RectAreaLightInterpreter";
 export * from "./light/SpotLightInterpreter";
 export * from "./texture/TextureInterpreter";
 export * from './helper/AxesHelperInterpreter'
-export * from "./ServiceSchedulerInterpreter";
-export * from "./SceneServiceInterpreter";
+export * from "./SceneInterpreter";
+export * from "./Scene3DServiceInterpreter";
 export * from "./NodeInterpreter";
 export * from "./MeshInterpreter";
 export * from './InstancedMeshInterpreter'
-export * from './TextInterpreter'
+export * from './Text3DInterpreter'
 export * from "./PointsInterpreter";
 export * from './ParticleInterpreter'
 export * from "./SpriteInterpreter";

package/src/interpreter/light/AmbientLightInterpreter.ts

@@ -1,30 +1,28 @@
-import { AmbientLight } from "three";
+import { AmbientLight as ThreeAmbientLight } from "three";
 import { PickupObject } from "@vyr/engine";
 import { NodeInterpreter } from "../NodeInterpreter";
-import { AmbientLightDescriptor } from "../../descriptor";
+import { AmbientLight } from "../../descriptor";
 import { NodeActor } from "../../actor";
 
-class AmbientLightInterpreter extends NodeInterpreter {
-    static type = AmbientLightDescriptor.type
+export class AmbientLightInterpreter extends NodeInterpreter {
+    static type = AmbientLight.type
 
-    protected createActor(descriptor: AmbientLightDescriptor) {
-        const actor = new NodeActor(new AmbientLight())
+    protected createActor(descriptor: AmbientLight) {
+        const actor = new NodeActor(new ThreeAmbientLight())
         return actor
     }
 
-    setLight(actor: NodeActor<AmbientLight>, descriptor: AmbientLightDescriptor) {
-        actor.object.color.set(descriptor.color)
+    setLight(actor: NodeActor<ThreeAmbientLight>, descriptor: AmbientLight) {
+        actor.object.color.setStyle(descriptor.color)
         actor.object.intensity = descriptor.intensity
     }
 
-    update(descriptor: AmbientLightDescriptor) {
+    update(descriptor: AmbientLight) {
         super.update(descriptor)
-        const actor = this.getActor<NodeActor<AmbientLight>>(descriptor)
+        const actor = this.getActor<NodeActor<ThreeAmbientLight>>(descriptor)
         this.setLight(actor, descriptor)
     }
 
-    pickup(descriptor: AmbientLightDescriptor, result: PickupObject[]) { }
+    pickup(descriptor: AmbientLight, result: PickupObject[]) { }
 }
-NodeInterpreter.register(AmbientLightInterpreter)
-
-export { AmbientLightInterpreter }
+NodeInterpreter.register(AmbientLightInterpreter)