@vyr/three 0.0.33 → 0.0.35

package/src/interpreter/light/DirectionalLightInterpreter.ts

@@ -1,21 +1,21 @@
-import { DirectionalLight, Object3D } from "three";
+import { DirectionalLight as ThreeDirectionalLight, Object3D } from "three";
 import { Descriptor, PickupObject } from "@vyr/engine";
 import { NodeInterpreter } from "../NodeInterpreter";
-import { DirectionalLightDescriptor } from "../../descriptor";
+import { DirectionalLight } from "../../descriptor";
 import { NodeActor } from "../../actor";
 
-class DirectionalLightInterpreter extends NodeInterpreter {
-    static type = DirectionalLightDescriptor.type
+export class DirectionalLightInterpreter extends NodeInterpreter {
+    static type = DirectionalLight.type
 
     target: Object3D | null = null
 
-    protected createActor(descriptor: DirectionalLightDescriptor) {
-        const actor = new NodeActor(new DirectionalLight())
+    protected createActor(descriptor: DirectionalLight) {
+        const actor = new NodeActor(new ThreeDirectionalLight())
         return actor
     }
 
-    setLight(actor: NodeActor<DirectionalLight>, descriptor: DirectionalLightDescriptor) {
-        actor.object.color.set(descriptor.color)
+    setLight(actor: NodeActor<ThreeDirectionalLight>, descriptor: DirectionalLight) {
+        actor.object.color.setStyle(descriptor.color)
         actor.object.intensity = descriptor.intensity
         actor.object.shadow.bias = descriptor.bias
         actor.object.shadow.normalBias = descriptor.normalBias
@@ -41,7 +41,7 @@ class DirectionalLightInterpreter extends NodeInterpreter {
         actor.object.shadow.camera.updateProjectionMatrix()
     }
 
-    setTarget(actor: NodeActor<DirectionalLight>, descriptor: DirectionalLightDescriptor) {
+    setTarget(actor: NodeActor<ThreeDirectionalLight>, descriptor: DirectionalLight) {
         let targetValue = descriptor.target
         if (targetValue === '') {
             const target = new Object3D()
@@ -64,21 +64,19 @@ class DirectionalLightInterpreter extends NodeInterpreter {
 
     }
 
-    update(descriptor: DirectionalLightDescriptor) {
+    update(descriptor: DirectionalLight) {
         super.update(descriptor)
-        const actor = this.getActor<NodeActor<DirectionalLight>>(descriptor)
+        const actor = this.getActor<NodeActor<ThreeDirectionalLight>>(descriptor)
         this.setLight(actor, descriptor)
         this.setTarget(actor, descriptor)
     }
 
-    free(descriptor: DirectionalLightDescriptor) {
-        const actor = this.getActor<NodeActor<DirectionalLight>>(descriptor)
+    free(descriptor: DirectionalLight) {
+        const actor = this.getActor<NodeActor<ThreeDirectionalLight>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 
-    pickup(descriptor: DirectionalLightDescriptor, result: PickupObject[]) { }
+    pickup(descriptor: DirectionalLight, result: PickupObject[]) { }
 }
-NodeInterpreter.register(DirectionalLightInterpreter)
-
-export { DirectionalLightInterpreter }
+NodeInterpreter.register(DirectionalLightInterpreter)

package/src/interpreter/light/HemisphereLightInterpreter.ts

@@ -1,32 +1,29 @@
-import { HemisphereLight } from "three";
-import { PickupObject } from "@vyr/engine";
+import { HemisphereLight as ThreeHemisphereLight } from "three";
+import { Descriptor, PickupObject } from "@vyr/engine";
 import { NodeInterpreter } from "../NodeInterpreter";
-import { HemisphereLightDescriptor } from "../../descriptor";
+import { HemisphereLight } from "../../descriptor";
 import { NodeActor } from "../../actor";
 
-class HemisphereLightInterpreter extends NodeInterpreter {
-    static type = HemisphereLightDescriptor.type
+export class HemisphereLightInterpreter extends NodeInterpreter {
+    static type = HemisphereLight.type
 
-    protected createActor(descriptor: HemisphereLightDescriptor) {
-        const actor = new NodeActor(new HemisphereLight())
+    protected createActor(descriptor: HemisphereLight) {
+        const actor = new NodeActor(new ThreeHemisphereLight())
         return actor
     }
 
-    setLight(actor: NodeActor<HemisphereLight>, descriptor: HemisphereLightDescriptor) {
-        actor.object.color.set(descriptor.color)
+    setLight(actor: NodeActor<ThreeHemisphereLight>, descriptor: HemisphereLight) {
+        actor.object.color.setStyle(descriptor.color)
         actor.object.intensity = descriptor.intensity
-        actor.object.groundColor.set(descriptor.groundColor)
+        actor.object.groundColor.setStyle(descriptor.groundColor)
     }
 
-    update(descriptor: HemisphereLightDescriptor) {
+    update(descriptor: HemisphereLight) {
         super.update(descriptor)
-        const actor = this.getActor<NodeActor<HemisphereLight>>(descriptor)
+        const actor = this.getActor<NodeActor<ThreeHemisphereLight>>(descriptor)
         this.setLight(actor, descriptor)
     }
 
-    pickup(descriptor: HemisphereLightDescriptor, result: PickupObject[]) { }
+    pickup(descriptor: HemisphereLight, result: PickupObject[]) { }
 }
-NodeInterpreter.register(HemisphereLightInterpreter)
-
-
-export { HemisphereLightInterpreter }
+NodeInterpreter.register(HemisphereLightInterpreter)

package/src/interpreter/light/PointLightInterpreter.ts

@@ -1,18 +1,18 @@
-import { PointLight } from "three";
+import { PointLight as ThreePointLight } from "three";
 import { PickupObject } from "@vyr/engine";
 import { NodeInterpreter } from "../NodeInterpreter";
-import { PointLightDescriptor } from "../../descriptor";
+import { PointLight } from "../../descriptor";
 import { NodeActor } from "../../actor";
 
-class PointLightInterpreter extends NodeInterpreter {
-    static type = PointLightDescriptor.type
+export class PointLightInterpreter extends NodeInterpreter {
+    static type = PointLight.type
 
-    protected createActor(descriptor: PointLightDescriptor) {
-        const actor = new NodeActor(new PointLight())
+    protected createActor(descriptor: PointLight) {
+        const actor = new NodeActor(new ThreePointLight())
         return actor
     }
 
-    setLight(actor: NodeActor<PointLight>, descriptor: PointLightDescriptor) {
+    setLight(actor: NodeActor<ThreePointLight>, descriptor: PointLight) {
         actor.object.color.set(descriptor.color)
         actor.object.intensity = descriptor.intensity
         actor.object.decay = descriptor.decay
@@ -26,21 +26,18 @@ class PointLightInterpreter extends NodeInterpreter {
     }
 
 
-    update(descriptor: PointLightDescriptor) {
+    update(descriptor: PointLight) {
         super.update(descriptor)
-        const actor = this.getActor<NodeActor<PointLight>>(descriptor)
+        const actor = this.getActor<NodeActor<ThreePointLight>>(descriptor)
         this.setLight(actor, descriptor)
     }
 
-    free(descriptor: PointLightDescriptor) {
-        const actor = this.getActor<NodeActor<PointLight>>(descriptor)
+    free(descriptor: PointLight) {
+        const actor = this.getActor<NodeActor<ThreePointLight>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 
-    pickup(descriptor: PointLightDescriptor, result: PickupObject[]) { }
+    pickup(descriptor: PointLight, result: PickupObject[]) { }
 }
-NodeInterpreter.register(PointLightInterpreter)
-
-
-export { PointLightInterpreter }
+NodeInterpreter.register(PointLightInterpreter)

package/src/interpreter/light/RectAreaLightInterpreter.ts

@@ -1,18 +1,18 @@
-import { RectAreaLight } from "three";
+import { RectAreaLight as ThreeRectAreaLight } from "three";
 import { PickupObject } from "@vyr/engine";
 import { NodeInterpreter } from "../NodeInterpreter";
-import { RectAreaLightDescriptor } from "../../descriptor";
+import { RectAreaLight } from "../../descriptor";
 import { NodeActor } from "../../actor";
 
-class RectAreaLightInterpreter extends NodeInterpreter {
-    static type = RectAreaLightDescriptor.type
+export class RectAreaLightInterpreter extends NodeInterpreter {
+    static type = RectAreaLight.type
 
-    protected createActor(descriptor: RectAreaLightDescriptor) {
-        const actor = new NodeActor(new RectAreaLight())
+    protected createActor(descriptor: RectAreaLight) {
+        const actor = new NodeActor(new ThreeRectAreaLight())
         return actor
     }
 
-    setLight(actor: NodeActor<RectAreaLight>, descriptor: RectAreaLightDescriptor) {
+    setLight(actor: NodeActor<ThreeRectAreaLight>, descriptor: RectAreaLight) {
         actor.object.color.set(descriptor.color)
         actor.object.intensity = descriptor.intensity
         actor.object.width = descriptor.width
@@ -20,15 +20,13 @@ class RectAreaLightInterpreter extends NodeInterpreter {
         actor.object.power = descriptor.power
     }
 
-    update(descriptor: RectAreaLightDescriptor) {
+
+    update(descriptor: RectAreaLight) {
         super.update(descriptor)
-        const actor = this.getActor<NodeActor<RectAreaLight>>(descriptor)
+        const actor = this.getActor<NodeActor<ThreeRectAreaLight>>(descriptor)
         this.setLight(actor, descriptor)
     }
 
-    pickup(descriptor: RectAreaLightDescriptor, result: PickupObject[]) { }
+    pickup(descriptor: RectAreaLight, result: PickupObject[]) { }
 }
-NodeInterpreter.register(RectAreaLightInterpreter)
-
-
-export { RectAreaLightInterpreter }
+NodeInterpreter.register(RectAreaLightInterpreter)

package/src/interpreter/light/SpotLightInterpreter.ts

@@ -1,18 +1,18 @@
-import { Object3D, SpotLight } from "three";
+import { Object3D, SpotLight as ThreeSpotLight } from "three";
 import { Descriptor, PickupObject } from "@vyr/engine";
 import { NodeInterpreter } from "../NodeInterpreter";
-import { SpotLightDescriptor } from "../../descriptor";
+import { SpotLight } from "../../descriptor";
 import { NodeActor } from "../../actor";
 
-class SpotLightInterpreter extends NodeInterpreter {
-    static type = SpotLightDescriptor.type
+export class SpotLightInterpreter extends NodeInterpreter {
+    static type = SpotLight.type
 
-    protected createActor(descriptor: SpotLightDescriptor) {
-        const actor = new NodeActor(new SpotLight())
+    protected createActor(descriptor: SpotLight) {
+        const actor = new NodeActor(new ThreeSpotLight())
         return actor
     }
 
-    setLight(actor: NodeActor<SpotLight>, descriptor: SpotLightDescriptor) {
+    setLight(actor: NodeActor<ThreeSpotLight>, descriptor: SpotLight) {
         actor.object.color.set(descriptor.color)
         actor.object.intensity = descriptor.intensity
         actor.object.angle = descriptor.angle
@@ -27,7 +27,7 @@ class SpotLightInterpreter extends NodeInterpreter {
         actor.object.shadow.camera.far = camera.far
     }
 
-    setTarget(actor: NodeActor<SpotLight>, descriptor: SpotLightDescriptor) {
+    setTarget(actor: NodeActor<ThreeSpotLight>, descriptor: SpotLight) {
         if (descriptor.target === '') {
             const target = new Object3D()
             target.position.copy(actor.object.target.position)
@@ -47,22 +47,19 @@ class SpotLightInterpreter extends NodeInterpreter {
         }
     }
 
-    update(descriptor: SpotLightDescriptor) {
+    update(descriptor: SpotLight) {
         super.update(descriptor)
-        const actor = this.getActor<NodeActor<SpotLight>>(descriptor)
+        const actor = this.getActor<NodeActor<ThreeSpotLight>>(descriptor)
         this.setLight(actor, descriptor)
         this.setTarget(actor, descriptor)
     }
 
-    free(descriptor: SpotLightDescriptor) {
-        const actor = this.getActor<NodeActor<SpotLight>>(descriptor)
+    free(descriptor: SpotLight) {
+        const actor = this.getActor<NodeActor<ThreeSpotLight>>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
 
-    pickup(descriptor: SpotLightDescriptor, result: PickupObject[]) { }
+    pickup(descriptor: SpotLight, result: PickupObject[]) { }
 }
-NodeInterpreter.register(SpotLightInterpreter)
-
-
-export { SpotLightInterpreter }
+NodeInterpreter.register(SpotLightInterpreter)

package/src/interpreter/material/MaterialInterpreter.ts

@@ -1,18 +1,16 @@
-import { Material } from "three";
+import { Material as ThreeMaterial } from "three";
 import { Interpreter } from "@vyr/engine";
-import { MaterialDescriptor } from "../../descriptor";
+import { Material } from "../../descriptor";
 import { MaterialActor } from "../../actor";
-import { material as _material } from "../../utils";
 
-class MaterialInterpreter extends Interpreter {
-    static type = MaterialDescriptor.type
+export abstract class MaterialInterpreter extends Interpreter {
 
-    setProperty(material: Material, descriptor: MaterialDescriptor) {
+    setProperty(material: ThreeMaterial, descriptor: Material) {
         material.alphaTest = descriptor.alphaTest
         material.transparent = descriptor.transparent
         material.colorWrite = descriptor.colorWrite
         material.depthTest = descriptor.depthTest
-        material.depthWrite = descriptor.depthrWrite
+        material.depthWrite = descriptor.depthWrite
         //@ts-ignore
         material.side = descriptor.side
         //@ts-ignore
@@ -23,12 +21,9 @@ class MaterialInterpreter extends Interpreter {
         material.needsUpdate = true
     }
 
-    free(descriptor: MaterialDescriptor) {
+    free(descriptor: Material) {
         const actor = this.getActor<MaterialActor>(descriptor)
         actor.object.dispose()
         super.free(descriptor)
     }
-}
-Interpreter.register(MaterialInterpreter)
-
-export { MaterialInterpreter }
+}

package/src/interpreter/material/MeshBasicMaterialInterpreter.ts

@@ -1,22 +1,22 @@
-import { MeshBasicMaterial } from "three";
+import { MeshBasicMaterial as ThreeMeshBasicMaterial } from "three";
 import { MaterialInterpreter } from './MaterialInterpreter'
-import { MeshBasicMaterialDescriptor } from "../../descriptor";
+import { MeshBasicMaterial } from "../../descriptor";
 import { MaterialActor } from "../../actor";
 import { texture } from "../../utils";
 
-class MeshBasicMaterialInterpreter extends MaterialInterpreter {
-    static type = MeshBasicMaterialDescriptor.type
+export class MeshBasicMaterialInterpreter extends MaterialInterpreter {
+    static type = MeshBasicMaterial.type
 
-    protected createActor(descriptor: MeshBasicMaterialDescriptor) {
-        const actor = new MaterialActor(new MeshBasicMaterial())
+    protected createActor(descriptor: MeshBasicMaterial) {
+        const actor = new MaterialActor(new ThreeMeshBasicMaterial())
         return actor
     }
 
-    setProperty(material: MeshBasicMaterial, descriptor: MeshBasicMaterialDescriptor) {
+    setProperty(material: ThreeMeshBasicMaterial, descriptor: MeshBasicMaterial) {
         super.setProperty(material, descriptor)
 
-        material.color.setStyle(descriptor.color.value)
-        material.opacity = descriptor.color.opacity
+        material.color.setStyle(descriptor.color)
+        material.opacity = descriptor.opacity
         material.reflectivity = descriptor.reflectivity
         material.refractionRatio = descriptor.refractionRatio
         material.lightMapIntensity = descriptor.lightMapIntensity
@@ -26,9 +26,9 @@ class MeshBasicMaterialInterpreter extends MaterialInterpreter {
         material.wireframe = descriptor.wireframe
     }
 
-    update(descriptor: MeshBasicMaterialDescriptor) {
+    update(descriptor: MeshBasicMaterial) {
         super.update(descriptor)
-        const actor = this.getActor<MaterialActor<MeshBasicMaterial>>(descriptor)
+        const actor = this.getActor<MaterialActor<ThreeMeshBasicMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
         texture.setMap(actor.object, 'map', descriptor, this.graphics)
         texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics)
@@ -37,6 +37,4 @@ class MeshBasicMaterialInterpreter extends MaterialInterpreter {
         texture.setMap(actor.object, 'specularMap', descriptor, this.graphics)
     }
 }
-MaterialInterpreter.register(MeshBasicMaterialInterpreter)
-
-export { MeshBasicMaterialInterpreter }
+MaterialInterpreter.register(MeshBasicMaterialInterpreter)

package/src/interpreter/material/MeshPhongMaterialInterpreter.ts

@@ -1,22 +1,22 @@
-import { MeshPhongMaterial } from "three";
-import { MaterialInterpreter } from "./MaterialInterpreter";
-import { MeshPhongMaterialDescriptor } from "../../descriptor";
+import { MeshPhongMaterial as ThreeMeshPhongMaterial } from "three";
+import { MaterialInterpreter } from './MaterialInterpreter'
+import { MeshPhongMaterial } from "../../descriptor";
 import { MaterialActor } from "../../actor";
 import { texture } from "../../utils";
 
-class MeshPhongMaterialInterpreter extends MaterialInterpreter {
-    static type = MeshPhongMaterialDescriptor.type
+export class MeshPhongMaterialInterpreter extends MaterialInterpreter {
+    static type = MeshPhongMaterial.type
 
-    protected createActor(descriptor: MeshPhongMaterialDescriptor) {
-        const actor = new MaterialActor(new MeshPhongMaterial())
+    protected createActor(descriptor: MeshPhongMaterial) {
+        const actor = new MaterialActor(new ThreeMeshPhongMaterial())
         return actor
     }
 
-    setProperty(material: MeshPhongMaterial, descriptor: MeshPhongMaterialDescriptor) {
+    setProperty(material: ThreeMeshPhongMaterial, descriptor: MeshPhongMaterial) {
         super.setProperty(material, descriptor)
 
-        material.color.setStyle(descriptor.color.value)
-        material.opacity = descriptor.color.opacity
+        material.color.setStyle(descriptor.color)
+        material.opacity = descriptor.opacity
         material.emissive.setStyle(descriptor.emissive)
         material.specular.setStyle(descriptor.specular)
         material.reflectivity = descriptor.reflectivity
@@ -42,9 +42,9 @@ class MeshPhongMaterialInterpreter extends MaterialInterpreter {
         material.wireframe = descriptor.wireframe
     }
 
-    update(descriptor: MeshPhongMaterialDescriptor) {
+    update(descriptor: MeshPhongMaterial) {
         super.update(descriptor)
-        const actor = this.getActor<MaterialActor<MeshPhongMaterial>>(descriptor)
+        const actor = this.getActor<MaterialActor<ThreeMeshPhongMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
         texture.setMap(actor.object, 'map', descriptor, this.graphics)
         texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics)
@@ -57,6 +57,4 @@ class MeshPhongMaterialInterpreter extends MaterialInterpreter {
         texture.setMap(actor.object, 'normalMap', descriptor, this.graphics)
     }
 }
-MaterialInterpreter.register(MeshPhongMaterialInterpreter)
-
-export { MeshPhongMaterialInterpreter }
+MaterialInterpreter.register(MeshPhongMaterialInterpreter)

package/src/interpreter/material/MeshStandardMaterialInterpreter.ts

@@ -1,22 +1,22 @@
-import { MeshStandardMaterial } from "three";
-import { MaterialInterpreter } from "./MaterialInterpreter";
-import { MeshStandardMaterialDescriptor } from "../../descriptor";
+import { MeshStandardMaterial as ThreeMeshStandardMaterial } from "three";
+import { MaterialInterpreter } from './MaterialInterpreter'
+import { MeshStandardMaterial } from "../../descriptor";
 import { MaterialActor } from "../../actor";
 import { texture } from "../../utils";
 
-class MeshStandardMaterialInterpreter extends MaterialInterpreter {
-    static type = MeshStandardMaterialDescriptor.type
+export class MeshStandardMaterialInterpreter extends MaterialInterpreter {
+    static type = MeshStandardMaterial.type
 
-    protected createActor(descriptor: MeshStandardMaterialDescriptor) {
-        const actor = new MaterialActor(new MeshStandardMaterial())
+    protected createActor(descriptor: MeshStandardMaterial) {
+        const actor = new MaterialActor(new ThreeMeshStandardMaterial())
         return actor
     }
 
-    setProperty(material: MeshStandardMaterial, descriptor: MeshStandardMaterialDescriptor) {
+    setProperty(material: ThreeMeshStandardMaterial, descriptor: MeshStandardMaterial) {
         super.setProperty(material, descriptor)
 
-        material.color.setStyle(descriptor.color.value)
-        material.opacity = descriptor.color.opacity
+        material.color.setStyle(descriptor.color)
+        material.opacity = descriptor.opacity
         material.lightMapIntensity = descriptor.lightMapIntensity
         material.envMapIntensity = descriptor.envMapIntensity
         material.envMapRotation.set(descriptor.envMapRotation.x, descriptor.envMapRotation.y, descriptor.envMapRotation.z)
@@ -36,9 +36,9 @@ class MeshStandardMaterialInterpreter extends MaterialInterpreter {
         material.wireframe = descriptor.wireframe
     }
 
-    update(descriptor: MeshStandardMaterialDescriptor) {
+    update(descriptor: MeshStandardMaterial) {
         super.update(descriptor)
-        const actor = this.getActor<MaterialActor<MeshStandardMaterial>>(descriptor)
+        const actor = this.getActor<MaterialActor<ThreeMeshStandardMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
         texture.setMap(actor.object, 'map', descriptor, this.graphics)
         texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics)
@@ -52,6 +52,4 @@ class MeshStandardMaterialInterpreter extends MaterialInterpreter {
         texture.setMap(actor.object, 'roughnessMap', descriptor, this.graphics)
     }
 }
-MaterialInterpreter.register(MeshStandardMaterialInterpreter)
-
-export { MeshStandardMaterialInterpreter }
+MaterialInterpreter.register(MeshStandardMaterialInterpreter)

package/src/interpreter/material/PointsMaterialInterpreter.ts

@@ -1,35 +1,33 @@
-import { PointsMaterial } from "three";
+import { PointsMaterial as ThreePointsMaterial } from "three";
 import { MaterialInterpreter } from './MaterialInterpreter'
-import { PointsMaterialDescriptor } from "../../descriptor";
+import { PointsMaterial } from "../../descriptor";
 import { MaterialActor } from "../../actor";
 import { texture } from "../../utils";
 
-class PointsMaterialInterpreter extends MaterialInterpreter {
-    static type = PointsMaterialDescriptor.type
+export class PointsMaterialInterpreter extends MaterialInterpreter {
+    static type = PointsMaterial.type
 
-    protected createActor(descriptor: PointsMaterialDescriptor) {
-        const actor = new MaterialActor(new PointsMaterial())
+    protected createActor(descriptor: PointsMaterial) {
+        const actor = new MaterialActor(new ThreePointsMaterial())
         return actor
     }
 
-    setProperty(material: PointsMaterial, descriptor: PointsMaterialDescriptor) {
+    setProperty(material: ThreePointsMaterial, descriptor: PointsMaterial) {
         super.setProperty(material, descriptor)
 
-        material.color.setStyle(descriptor.color.value)
-        material.opacity = descriptor.color.opacity
+        material.color.setStyle(descriptor.color)
+        material.opacity = descriptor.opacity
         material.size = descriptor.size
         material.sizeAttenuation = descriptor.sizeAttenuation
         material.fog = descriptor.fog
     }
 
-    update(descriptor: PointsMaterialDescriptor) {
+    update(descriptor: PointsMaterial) {
         super.update(descriptor)
-        const actor = this.getActor<MaterialActor<PointsMaterial>>(descriptor)
+        const actor = this.getActor<MaterialActor<ThreePointsMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
         texture.setMap(actor.object, 'map', descriptor, this.graphics)
         texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics)
     }
 }
-MaterialInterpreter.register(PointsMaterialInterpreter)
-
-export { PointsMaterialInterpreter }
+MaterialInterpreter.register(PointsMaterialInterpreter)

package/src/interpreter/material/ShaderMaterialInterpreter.ts

@@ -1,20 +1,20 @@
-import { ShaderMaterial } from "three";
+import { ShaderMaterial as ThreeShaderMaterial } from "three";
 import { Asset, Scriptable, ScriptableArgs } from "@vyr/engine";
 import { MaterialInterpreter } from './MaterialInterpreter'
 import { MaterialActor } from "../../actor";
-import { ShaderMaterialAttribute, ShaderMaterialDescriptor } from "../../descriptor";
+import { ShaderMaterialAttribute, ShaderMaterial } from "../../descriptor";
 
-class ShaderMaterialInterpreter extends MaterialInterpreter {
-    static type = ShaderMaterialDescriptor.type
+export class ShaderMaterialInterpreter extends MaterialInterpreter {
+    static type = ShaderMaterial.type
     static defaultVertexShader = 'void main() { gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );}'
     static defaultFragmentShader = 'void main() { gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );}'
 
-    protected createActor(descriptor: ShaderMaterialDescriptor) {
-        const actor = new MaterialActor(new ShaderMaterial())
+    protected createActor(descriptor: ShaderMaterial) {
+        const actor = new MaterialActor(new ThreeShaderMaterial())
         return actor
     }
 
-    setProperty(material: ShaderMaterial, descriptor: ShaderMaterialDescriptor) {
+    setProperty(material: ThreeShaderMaterial, descriptor: ShaderMaterial) {
         super.setProperty(material, descriptor)
         material.lights = descriptor.lights
         //@ts-ignore
@@ -23,29 +23,27 @@ class ShaderMaterialInterpreter extends MaterialInterpreter {
         material.wireframe = descriptor.wireframe
     }
 
-    setShaderAsset(material: ShaderMaterial, descriptor: ShaderMaterialDescriptor) {
+    setShaderAsset(material: ThreeShaderMaterial, descriptor: ShaderMaterial) {
         material.uniforms = {}
         material.vertexShader = ShaderMaterialInterpreter.defaultVertexShader
         material.fragmentShader = ShaderMaterialInterpreter.defaultFragmentShader
         material.uniformsNeedUpdate = true
 
         if (descriptor.shader) {
-            const shaderAsset = Asset.get<Scriptable<ScriptableArgs<undefined, undefined, undefined>>>(descriptor.shader)
+            const shaderAsset = Scriptable.use(descriptor.shader)
             if (shaderAsset === null) return
-            const attribute: ShaderMaterialAttribute = shaderAsset.execute(this.graphics, { input: undefined, result: undefined, trigger: descriptor })
+            const attribute: ShaderMaterialAttribute = shaderAsset.execute(this.graphics, descriptor.uuid, {})
             material.uniforms = attribute.uniforms
             material.fragmentShader = attribute.fragmentShader
             material.vertexShader = attribute.vertexShader
         }
     }
 
-    update(descriptor: ShaderMaterialDescriptor) {
+    update(descriptor: ShaderMaterial) {
         super.update(descriptor)
-        const actor = this.getActor<MaterialActor<ShaderMaterial>>(descriptor)
+        const actor = this.getActor<MaterialActor<ThreeShaderMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
         this.setShaderAsset(actor.object, descriptor)
     }
 }
-MaterialInterpreter.register(ShaderMaterialInterpreter)
-
-export { ShaderMaterialInterpreter }
+MaterialInterpreter.register(ShaderMaterialInterpreter)

package/src/interpreter/material/ShadowMaterialInterpreter.ts

@@ -1,30 +1,27 @@
-import { ShadowMaterial } from "three";
+import { ShadowMaterial as ThreeShadowMaterial } from "three";
 import { MaterialInterpreter } from './MaterialInterpreter'
-import { ShadowMaterialDescriptor } from "../../descriptor";
+import { ShadowMaterial } from "../../descriptor";
 import { MaterialActor } from "../../actor";
 
-class ShadowMaterialInterpreter extends MaterialInterpreter {
-    static type = ShadowMaterialDescriptor.type
+export class ShadowMaterialInterpreter extends MaterialInterpreter {
+    static type = ShadowMaterial.type
 
-    protected createActor(descriptor: ShadowMaterialDescriptor) {
-        const actor = new MaterialActor(new ShadowMaterial())
+    protected createActor(descriptor: ShadowMaterial) {
+        const actor = new MaterialActor(new ThreeShadowMaterial())
         return actor
     }
 
-    setProperty(material: ShadowMaterial, descriptor: ShadowMaterialDescriptor) {
+    setProperty(material: ThreeShadowMaterial, descriptor: ShadowMaterial) {
         super.setProperty(material, descriptor)
 
-        material.color.setStyle(descriptor.color.value)
-        material.opacity = descriptor.color.opacity
-        material.fog = descriptor.fog
+        material.color.setStyle(descriptor.color)
+        material.opacity = descriptor.opacity
     }
 
-    update(descriptor: ShadowMaterialDescriptor) {
+    update(descriptor: ShadowMaterial) {
         super.update(descriptor)
-        const actor = this.getActor<MaterialActor<ShadowMaterial>>(descriptor)
+        const actor = this.getActor<MaterialActor<ThreeShadowMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
     }
 }
-MaterialInterpreter.register(ShadowMaterialInterpreter)
-
-export { ShadowMaterialInterpreter }
+MaterialInterpreter.register(ShadowMaterialInterpreter)