@vyr/three 0.0.1 → 0.0.2

package/src/interpreter/light/DirectionalLightInterpreter.ts

@@ -1,5 +1,5 @@
 import { DirectionalLight, Object3D } from "three";
-import { Descriptor, PickupObject, UpdateArgs } from "@vyr/engine";
+import { Descriptor, PickupObject } from "@vyr/engine";
 import { NodeInterpreter } from "../NodeInterpreter";
 import { DirectionalLightDescriptor } from "../../descriptor";
 import { NodeActor } from "../../actor";
@@ -9,12 +9,12 @@ class DirectionalLightInterpreter extends NodeInterpreter {
 
     target: Object3D | null = null
 
-    protected createActor(descriptor: DirectionalLightDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: DirectionalLightDescriptor) {
         const actor = new NodeActor(new DirectionalLight())
         return actor
     }
 
-    setLight(actor: NodeActor<DirectionalLight>, descriptor: DirectionalLightDescriptor, args: UpdateArgs) {
+    setLight(actor: NodeActor<DirectionalLight>, descriptor: DirectionalLightDescriptor) {
         actor.object.color.set(descriptor.color)
         actor.object.intensity = descriptor.intensity
         actor.object.shadow.bias = descriptor.bias
@@ -41,7 +41,7 @@ class DirectionalLightInterpreter extends NodeInterpreter {
         actor.object.shadow.camera.updateProjectionMatrix()
     }
 
-    setTarget(actor: NodeActor<DirectionalLight>, descriptor: DirectionalLightDescriptor, args: UpdateArgs) {
+    setTarget(actor: NodeActor<DirectionalLight>, descriptor: DirectionalLightDescriptor) {
         let targetValue = descriptor.target
         if (targetValue === '') {
             const target = new Object3D()
@@ -50,7 +50,7 @@ class DirectionalLightInterpreter extends NodeInterpreter {
         } else {
             const target = Descriptor.get<Descriptor>(targetValue)
             if (target !== null) {
-                const targetActor = this.graphics.getActor<NodeActor>(target, args)
+                const targetActor = this.graphics.getActor<NodeActor>(target)
                 if (targetActor instanceof NodeActor) {
                     actor.object.target = targetActor.object
                 } else {
@@ -64,20 +64,20 @@ class DirectionalLightInterpreter extends NodeInterpreter {
 
     }
 
-    update(descriptor: DirectionalLightDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<NodeActor<DirectionalLight>>(descriptor, args)
-        this.setLight(actor, descriptor, args)
-        this.setTarget(actor, descriptor, args)
+    update(descriptor: DirectionalLightDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<NodeActor<DirectionalLight>>(descriptor)
+        this.setLight(actor, descriptor)
+        this.setTarget(actor, descriptor)
     }
 
-    free(descriptor: DirectionalLightDescriptor, args: UpdateArgs) {
-        const actor = this.getActor<NodeActor<DirectionalLight>>(descriptor, args)
+    free(descriptor: DirectionalLightDescriptor) {
+        const actor = this.getActor<NodeActor<DirectionalLight>>(descriptor)
         actor.object.dispose()
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 
-    pickup(descriptor: DirectionalLightDescriptor, args: UpdateArgs, result: PickupObject[]) { }
+    pickup(descriptor: DirectionalLightDescriptor, result: PickupObject[]) { }
 }
 NodeInterpreter.register(DirectionalLightInterpreter)
 

package/src/interpreter/light/HemisphereLightInterpreter.ts

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

package/src/interpreter/light/PointLightInterpreter.ts

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

package/src/interpreter/light/RectAreaLightInterpreter.ts

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

package/src/interpreter/light/SpotLightInterpreter.ts

@@ -1,5 +1,5 @@
 import { Object3D, SpotLight } from "three";
-import { Descriptor, PickupObject, UpdateArgs } from "@vyr/engine";
+import { Descriptor, PickupObject } from "@vyr/engine";
 import { NodeInterpreter } from "../NodeInterpreter";
 import { SpotLightDescriptor } from "../../descriptor";
 import { NodeActor } from "../../actor";
@@ -7,12 +7,12 @@ import { NodeActor } from "../../actor";
 class SpotLightInterpreter extends NodeInterpreter {
     static type = SpotLightDescriptor.type
 
-    protected createActor(descriptor: SpotLightDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: SpotLightDescriptor) {
         const actor = new NodeActor(new SpotLight())
         return actor
     }
 
-    setLight(actor: NodeActor<SpotLight>, descriptor: SpotLightDescriptor, args: UpdateArgs) {
+    setLight(actor: NodeActor<SpotLight>, descriptor: SpotLightDescriptor) {
         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, args: UpdateArgs) {
+    setTarget(actor: NodeActor<SpotLight>, descriptor: SpotLightDescriptor) {
         if (descriptor.target === '') {
             const target = new Object3D()
             target.position.copy(actor.object.target.position)
@@ -35,7 +35,7 @@ class SpotLightInterpreter extends NodeInterpreter {
         } else {
             const target = Descriptor.get<Descriptor>(descriptor.target)
             if (target !== null) {
-                const targetActor = this.graphics.getActor<NodeActor>(target, args)
+                const targetActor = this.graphics.getActor<NodeActor>(target)
                 if (targetActor instanceof NodeActor) {
                     actor.object.target = targetActor.object
                 } else {
@@ -47,20 +47,20 @@ class SpotLightInterpreter extends NodeInterpreter {
         }
     }
 
-    update(descriptor: SpotLightDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<NodeActor<SpotLight>>(descriptor, args)
-        this.setLight(actor, descriptor, args)
-        this.setTarget(actor, descriptor, args)
+    update(descriptor: SpotLightDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<NodeActor<SpotLight>>(descriptor)
+        this.setLight(actor, descriptor)
+        this.setTarget(actor, descriptor)
     }
 
-    free(descriptor: SpotLightDescriptor, args: UpdateArgs) {
-        const actor = this.getActor<NodeActor<SpotLight>>(descriptor, args)
+    free(descriptor: SpotLightDescriptor) {
+        const actor = this.getActor<NodeActor<SpotLight>>(descriptor)
         actor.object.dispose()
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 
-    pickup(descriptor: SpotLightDescriptor, args: UpdateArgs, result: PickupObject[]) { }
+    pickup(descriptor: SpotLightDescriptor, result: PickupObject[]) { }
 }
 NodeInterpreter.register(SpotLightInterpreter)
 

package/src/interpreter/material/MaterialInterpreter.ts

@@ -1,5 +1,5 @@
 import { Material } from "three";
-import { Interpreter, UpdateArgs } from "@vyr/engine";
+import { Interpreter } from "@vyr/engine";
 import { MaterialDescriptor } from "../../descriptor";
 import { MaterialActor } from "../../actor";
 import { material as _material } from "../../utils";
@@ -23,10 +23,10 @@ class MaterialInterpreter extends Interpreter {
         material.needsUpdate = true
     }
 
-    free(descriptor: MaterialDescriptor, args: UpdateArgs) {
-        const actor = this.getActor<MaterialActor>(descriptor, args)
+    free(descriptor: MaterialDescriptor) {
+        const actor = this.getActor<MaterialActor>(descriptor)
         actor.object.dispose()
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 }
 Interpreter.register(MaterialInterpreter)

package/src/interpreter/material/MeshBasicMaterialInterpreter.ts

@@ -1,5 +1,4 @@
 import { MeshBasicMaterial } from "three";
-import { UpdateArgs } from "@vyr/engine";
 import { MaterialInterpreter } from './MaterialInterpreter'
 import { MeshBasicMaterialDescriptor } from "../../descriptor";
 import { MaterialActor } from "../../actor";
@@ -8,7 +7,7 @@ import { texture } from "../../utils";
 class MeshBasicMaterialInterpreter extends MaterialInterpreter {
     static type = MeshBasicMaterialDescriptor.type
 
-    protected createActor(descriptor: MeshBasicMaterialDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: MeshBasicMaterialDescriptor) {
         const actor = new MaterialActor(new MeshBasicMaterial())
         return actor
     }
@@ -27,15 +26,15 @@ class MeshBasicMaterialInterpreter extends MaterialInterpreter {
         material.wireframe = descriptor.wireframe
     }
 
-    update(descriptor: MeshBasicMaterialDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<MaterialActor<MeshBasicMaterial>>(descriptor, args)
+    update(descriptor: MeshBasicMaterialDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<MaterialActor<MeshBasicMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
-        texture.setMap(actor.object, 'map', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'envMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'lightMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'specularMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'map', descriptor, this.graphics)
+        texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'envMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'lightMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'specularMap', descriptor, this.graphics)
     }
 }
 MaterialInterpreter.register(MeshBasicMaterialInterpreter)

package/src/interpreter/material/MeshPhongMaterialInterpreter.ts

@@ -1,5 +1,4 @@
 import { MeshPhongMaterial } from "three";
-import { UpdateArgs } from "@vyr/engine";
 import { MaterialInterpreter } from "./MaterialInterpreter";
 import { MeshPhongMaterialDescriptor } from "../../descriptor";
 import { MaterialActor } from "../../actor";
@@ -8,7 +7,7 @@ import { texture } from "../../utils";
 class MeshPhongMaterialInterpreter extends MaterialInterpreter {
     static type = MeshPhongMaterialDescriptor.type
 
-    protected createActor(descriptor: MeshPhongMaterialDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: MeshPhongMaterialDescriptor) {
         const actor = new MaterialActor(new MeshPhongMaterial())
         return actor
     }
@@ -43,19 +42,19 @@ class MeshPhongMaterialInterpreter extends MaterialInterpreter {
         material.wireframe = descriptor.wireframe
     }
 
-    update(descriptor: MeshPhongMaterialDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<MaterialActor<MeshPhongMaterial>>(descriptor, args)
+    update(descriptor: MeshPhongMaterialDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<MaterialActor<MeshPhongMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
-        texture.setMap(actor.object, 'map', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'envMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'lightMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'specularMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'aoMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'bumpMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'emissiveMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'normalMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'map', descriptor, this.graphics)
+        texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'envMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'lightMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'specularMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'aoMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'bumpMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'emissiveMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'normalMap', descriptor, this.graphics)
     }
 }
 MaterialInterpreter.register(MeshPhongMaterialInterpreter)

package/src/interpreter/material/MeshStandardMaterialInterpreter.ts

@@ -1,5 +1,4 @@
 import { MeshStandardMaterial } from "three";
-import { UpdateArgs } from "@vyr/engine";
 import { MaterialInterpreter } from "./MaterialInterpreter";
 import { MeshStandardMaterialDescriptor } from "../../descriptor";
 import { MaterialActor } from "../../actor";
@@ -8,7 +7,7 @@ import { texture } from "../../utils";
 class MeshStandardMaterialInterpreter extends MaterialInterpreter {
     static type = MeshStandardMaterialDescriptor.type
 
-    protected createActor(descriptor: MeshStandardMaterialDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: MeshStandardMaterialDescriptor) {
         const actor = new MaterialActor(new MeshStandardMaterial())
         return actor
     }
@@ -37,20 +36,20 @@ class MeshStandardMaterialInterpreter extends MaterialInterpreter {
         material.wireframe = descriptor.wireframe
     }
 
-    update(descriptor: MeshStandardMaterialDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<MaterialActor<MeshStandardMaterial>>(descriptor, args)
+    update(descriptor: MeshStandardMaterialDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<MaterialActor<MeshStandardMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
-        texture.setMap(actor.object, 'map', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'lightMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'aoMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'bumpMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'displacementMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'emissiveMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'metalnessMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'normalMap', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'roughnessMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'map', descriptor, this.graphics)
+        texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'lightMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'aoMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'bumpMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'displacementMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'emissiveMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'metalnessMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'normalMap', descriptor, this.graphics)
+        texture.setMap(actor.object, 'roughnessMap', descriptor, this.graphics)
     }
 }
 MaterialInterpreter.register(MeshStandardMaterialInterpreter)

package/src/interpreter/material/PointsMaterialInterpreter.ts

@@ -1,5 +1,4 @@
 import { PointsMaterial } from "three";
-import { UpdateArgs } from "@vyr/engine";
 import { MaterialInterpreter } from './MaterialInterpreter'
 import { PointsMaterialDescriptor } from "../../descriptor";
 import { MaterialActor } from "../../actor";
@@ -8,7 +7,7 @@ import { texture } from "../../utils";
 class PointsMaterialInterpreter extends MaterialInterpreter {
     static type = PointsMaterialDescriptor.type
 
-    protected createActor(descriptor: PointsMaterialDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: PointsMaterialDescriptor) {
         const actor = new MaterialActor(new PointsMaterial())
         return actor
     }
@@ -23,12 +22,12 @@ class PointsMaterialInterpreter extends MaterialInterpreter {
         material.fog = descriptor.fog
     }
 
-    update(descriptor: PointsMaterialDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<MaterialActor<PointsMaterial>>(descriptor, args)
+    update(descriptor: PointsMaterialDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<MaterialActor<PointsMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
-        texture.setMap(actor.object, 'map', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'map', descriptor, this.graphics)
+        texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics)
     }
 }
 MaterialInterpreter.register(PointsMaterialInterpreter)

package/src/interpreter/material/ShaderMaterialInterpreter.ts

@@ -1,5 +1,5 @@
 import { ShaderMaterial } from "three";
-import { Asset, Scriptable, UpdateArgs } from "@vyr/engine";
+import { Asset, Scriptable, ScriptableArgs } from "@vyr/engine";
 import { MaterialInterpreter } from './MaterialInterpreter'
 import { MaterialActor } from "../../actor";
 import { ShaderMaterialAttribute, ShaderMaterialDescriptor } from "../../descriptor";
@@ -9,7 +9,7 @@ class ShaderMaterialInterpreter extends MaterialInterpreter {
     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, args: UpdateArgs) {
+    protected createActor(descriptor: ShaderMaterialDescriptor) {
         const actor = new MaterialActor(new ShaderMaterial())
         return actor
     }
@@ -23,27 +23,27 @@ class ShaderMaterialInterpreter extends MaterialInterpreter {
         material.wireframe = descriptor.wireframe
     }
 
-    setShaderAsset(material: ShaderMaterial, descriptor: ShaderMaterialDescriptor, args: UpdateArgs) {
+    setShaderAsset(material: ShaderMaterial, descriptor: ShaderMaterialDescriptor) {
         material.uniforms = {}
         material.vertexShader = ShaderMaterialInterpreter.defaultVertexShader
         material.fragmentShader = ShaderMaterialInterpreter.defaultFragmentShader
         material.uniformsNeedUpdate = true
 
         if (descriptor.shader) {
-            const shaderAsset = Asset.get<Scriptable>(descriptor.shader)
+            const shaderAsset = Asset.get<Scriptable<ScriptableArgs<undefined, undefined, undefined>>>(descriptor.shader)
             if (shaderAsset === null) return
-            const attribute: ShaderMaterialAttribute = shaderAsset.execute(descriptor, this.graphics, args)
+            const attribute: ShaderMaterialAttribute = shaderAsset.execute(this.graphics, { input: undefined, result: undefined, trigger: descriptor })
             material.uniforms = attribute.uniforms
             material.fragmentShader = attribute.fragmentShader
             material.vertexShader = attribute.vertexShader
         }
     }
 
-    update(descriptor: ShaderMaterialDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<MaterialActor<ShaderMaterial>>(descriptor, args)
+    update(descriptor: ShaderMaterialDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<MaterialActor<ShaderMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
-        this.setShaderAsset(actor.object, descriptor, args)
+        this.setShaderAsset(actor.object, descriptor)
     }
 }
 MaterialInterpreter.register(ShaderMaterialInterpreter)

package/src/interpreter/material/ShadowMaterialInterpreter.ts

@@ -1,5 +1,4 @@
 import { ShadowMaterial } from "three";
-import { UpdateArgs } from "@vyr/engine";
 import { MaterialInterpreter } from './MaterialInterpreter'
 import { ShadowMaterialDescriptor } from "../../descriptor";
 import { MaterialActor } from "../../actor";
@@ -7,7 +6,7 @@ import { MaterialActor } from "../../actor";
 class ShadowMaterialInterpreter extends MaterialInterpreter {
     static type = ShadowMaterialDescriptor.type
 
-    protected createActor(descriptor: ShadowMaterialDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: ShadowMaterialDescriptor) {
         const actor = new MaterialActor(new ShadowMaterial())
         return actor
     }
@@ -20,9 +19,9 @@ class ShadowMaterialInterpreter extends MaterialInterpreter {
         material.fog = descriptor.fog
     }
 
-    update(descriptor: ShadowMaterialDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<MaterialActor<ShadowMaterial>>(descriptor, args)
+    update(descriptor: ShadowMaterialDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<MaterialActor<ShadowMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
     }
 }

package/src/interpreter/material/SpriteMaterialInterpreter.ts

@@ -1,5 +1,4 @@
 import { SpriteMaterial } from "three";
-import { UpdateArgs } from "@vyr/engine";
 import { MaterialInterpreter } from './MaterialInterpreter'
 import { SpriteMaterialDescriptor } from "../../descriptor";
 import { MaterialActor } from "../../actor";
@@ -8,7 +7,7 @@ import { texture } from "../../utils";
 class SpriteMaterialInterpreter extends MaterialInterpreter {
     static type = SpriteMaterialDescriptor.type
 
-    protected createActor(descriptor: SpriteMaterialDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: SpriteMaterialDescriptor) {
         const actor = new MaterialActor(new SpriteMaterial())
         return actor
     }
@@ -23,12 +22,12 @@ class SpriteMaterialInterpreter extends MaterialInterpreter {
         material.fog = descriptor.fog
     }
 
-    update(descriptor: SpriteMaterialDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<MaterialActor<SpriteMaterial>>(descriptor, args)
+    update(descriptor: SpriteMaterialDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<MaterialActor<SpriteMaterial>>(descriptor)
         this.setProperty(actor.object, descriptor)
-        texture.setMap(actor.object, 'map', descriptor, this.graphics, args)
-        texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'map', descriptor, this.graphics)
+        texture.setMap(actor.object, 'alphaMap', descriptor, this.graphics)
     }
 }
 MaterialInterpreter.register(SpriteMaterialInterpreter)

package/src/interpreter/texture/TextureInterpreter.ts

@@ -1,12 +1,12 @@
 import { Texture } from "three";
-import { Asset, Interpreter, UpdateArgs } from "@vyr/engine";
+import { Asset, Interpreter } from "@vyr/engine";
 import { TextureDescriptor } from '../../descriptor'
 import { TextureActor } from "../../actor";
 
 class TextureInterpreter extends Interpreter {
     static type = TextureDescriptor.type
 
-    protected createActor(descriptor: TextureDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: TextureDescriptor) {
         const actor = new TextureActor(new Texture())
         return actor
     }
@@ -40,18 +40,18 @@ class TextureInterpreter extends Interpreter {
         }
     }
 
-    update(descriptor: TextureDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        let actor = this.getActor<TextureActor>(descriptor, args)
+    update(descriptor: TextureDescriptor) {
+        super.update(descriptor)
+        let actor = this.getActor<TextureActor>(descriptor)
         this.setProperty(actor, descriptor)
         this.setImage(actor, descriptor)
         if (actor.object.image) actor.object.needsUpdate = true
     }
 
-    free(descriptor: TextureDescriptor, args: UpdateArgs) {
-        const actor = this.getActor<TextureActor>(descriptor, args)
+    free(descriptor: TextureDescriptor) {
+        const actor = this.getActor<TextureActor>(descriptor)
         actor.object.dispose()
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 }
 Interpreter.register(TextureInterpreter)