@vyr/three 0.0.1

package/src/interpreter/geometry/SphereGeometryInterpreter.ts

@@ -0,0 +1,34 @@
+import { BufferGeometry, SphereGeometry } from "three";
+import { Interpreter, UpdateArgs } from "@vyr/engine";
+import { SphereGeometryDescriptor } from "../../descriptor";
+import { GeometryActor } from "../../actor";
+
+class SphereGeometryInterpreter extends Interpreter {
+    static type = SphereGeometryDescriptor.type
+
+    protected createActor(descriptor: SphereGeometryDescriptor, args: UpdateArgs) {
+        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)
+        actor.object.copy(source)
+        source.dispose()
+    }
+
+    update(descriptor: SphereGeometryDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<GeometryActor<SphereGeometry>>(descriptor, args)
+        this.setAttribute(actor, descriptor)
+    }
+
+    free(descriptor: SphereGeometryDescriptor, args: UpdateArgs) {
+        const actor = this.getActor<GeometryActor<SphereGeometry>>(descriptor, args)
+        actor.object.dispose()
+        super.free(descriptor, args)
+    }
+}
+Interpreter.register(SphereGeometryInterpreter)
+
+export { SphereGeometryInterpreter }

package/src/interpreter/geometry/SurfaceGeometryInterpreter.ts

@@ -0,0 +1,39 @@
+import { ExtrudeGeometry, Spherical, Vector3 } from "three";
+import { UpdateArgs } from "@vyr/engine";
+import { SurfaceGeometryDescriptor } from "../../descriptor";
+import { GeometryActor } from "../../actor";
+import { ExtrudeGeometryInterpreter } from "./ExtrudeGeometryInterpreter";
+
+class SurfaceGeometryInterpreter extends ExtrudeGeometryInterpreter {
+    static type = SurfaceGeometryDescriptor.type
+    /**
+    * 经纬度转V3
+    * @param lng 经度
+    * @param lat 纬度
+    * @param radius 半径
+    */
+    static lnglatToV3(lng: number, lat: number, radius: number) {
+        const theta = (90 + lng) * (Math.PI / 180)
+
+        const phi = (90 - lat) * (Math.PI / 180)
+
+        return new Vector3().setFromSpherical(new Spherical(radius, phi, theta))
+    }
+
+    setAttribute(actor: GeometryActor<ExtrudeGeometry>, descriptor: SurfaceGeometryDescriptor, args: UpdateArgs) {
+        super.setAttribute(actor, descriptor, args)
+        const position = actor.object.getAttribute('position')
+        for (let i = 0; i < position.count; i++) {
+            const v = SurfaceGeometryInterpreter.lnglatToV3(
+                position.getX(i),
+                position.getY(i),
+                position.getZ(i) + descriptor.radius
+            )
+            position.setXYZ(i, v.x, v.y, v.z)
+        }
+        actor.object.computeVertexNormals()
+    }
+}
+ExtrudeGeometryInterpreter.register(SurfaceGeometryInterpreter)
+
+export { SurfaceGeometryInterpreter }

package/src/interpreter/geometry/TubeGeometryInterpreter.ts

@@ -0,0 +1,42 @@
+import { BufferGeometry, CatmullRomCurve3, TubeGeometry, Vector3, } from "three";
+import { DatasetDescriptor, Interpreter, JsonAsset, UpdateArgs } from "@vyr/engine";
+import { TubeGeometryDescriptor } from "../../descriptor";
+import { GeometryActor } from "../../actor";
+import { geometry } from "../../utils";
+
+class TubeGeometryInterpreter extends Interpreter {
+    static type = TubeGeometryDescriptor.type
+
+    protected createActor(descriptor: TubeGeometryDescriptor, args: UpdateArgs) {
+        const actor = new GeometryActor(new BufferGeometry())
+        return actor
+    }
+
+    createPath(line: JsonAsset, descriptor: TubeGeometryDescriptor) {
+        const points = geometry.getPointsOfLineData(line, descriptor.offset)
+        return new CatmullRomCurve3(points, false)
+    }
+
+    setAttribute(actor: GeometryActor<TubeGeometry>, descriptor: TubeGeometryDescriptor, args: UpdateArgs) {
+        const data = DatasetDescriptor.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)
+        actor.object.copy(source)
+        source.dispose()
+    }
+
+    update(descriptor: TubeGeometryDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<GeometryActor<TubeGeometry>>(descriptor, args)
+        this.setAttribute(actor, descriptor, args)
+    }
+
+    free(descriptor: TubeGeometryDescriptor, args: UpdateArgs) {
+        const actor = this.getActor<GeometryActor<TubeGeometry>>(descriptor, args)
+        actor.object.dispose()
+        super.free(descriptor, args)
+    }
+}
+Interpreter.register(TubeGeometryInterpreter)
+
+export { TubeGeometryInterpreter }

package/src/interpreter/helper/AxesHelperInterpreter.ts

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

package/src/interpreter/index.ts

@@ -0,0 +1,45 @@
+export * from "./geometry/BoxGeometryInterpreter";
+export * from "./geometry/CircleGeometryInterpreter";
+export * from "./geometry/CylinderGeometryInterpreter";
+export * from "./geometry/PlaneGeometryInterpreter";
+export * from "./geometry/RingGeometryInterpreter";
+export * from "./geometry/SphereGeometryInterpreter";
+export * from "./geometry/ExtrudeGeometryInterpreter";
+export * from "./geometry/SurfaceGeometryInterpreter";
+export * from "./geometry/TubeGeometryInterpreter";
+export * from "./geometry/BufferGeometryInterpreter";
+export * from "./material/MaterialInterpreter";
+export * from "./material/MeshBasicMaterialInterpreter";
+export * from "./material/MeshPhongMaterialInterpreter";
+export * from "./material/MeshStandardMaterialInterpreter";
+export * from "./material/PointsMaterialInterpreter";
+export * from "./material/SpriteMaterialInterpreter";
+export * from "./material/ShadowMaterialInterpreter";
+export * from "./material/ShaderMaterialInterpreter";
+export * from './animation/AnimationActionInterpreter'
+export * from "./light/AmbientLightInterpreter";
+export * from "./light/DirectionalLightInterpreter";
+export * from "./light/HemisphereLightInterpreter";
+export * from "./light/PointLightInterpreter";
+export * from "./light/RectAreaLightInterpreter";
+export * from "./light/SpotLightInterpreter";
+export * from "./texture/TextureInterpreter";
+export * from './helper/AxesHelperInterpreter'
+export * from "./ServiceSchedulerInterpreter";
+export * from "./SceneServiceInterpreter";
+export * from "./NodeInterpreter";
+export * from "./MeshInterpreter";
+export * from './InstancedMeshInterpreter'
+export * from './TextInterpreter'
+export * from "./PointsInterpreter";
+export * from './ParticleInterpreter'
+export * from "./SpriteInterpreter";
+export * from './ModelInterpreter'
+export * from './HTMLConvertInterpreter'
+export * from './GeoMapInterpreter'
+export * from "./PerspectiveCameraInterpreter";
+export * from "./OrthographicCameraInterpreter";
+export * from "./OrbitControllerInterpreter";
+export * from "./TransformControllerInterpreter";
+// export * from './ComposerServiceInterpreter'
+// export * from './PassInterpreter'

package/src/interpreter/light/AmbientLightInterpreter.ts

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

package/src/interpreter/light/DirectionalLightInterpreter.ts

@@ -0,0 +1,84 @@
+import { DirectionalLight, Object3D } from "three";
+import { Descriptor, PickupObject, UpdateArgs } from "@vyr/engine";
+import { NodeInterpreter } from "../NodeInterpreter";
+import { DirectionalLightDescriptor } from "../../descriptor";
+import { NodeActor } from "../../actor";
+
+class DirectionalLightInterpreter extends NodeInterpreter {
+    static type = DirectionalLightDescriptor.type
+
+    target: Object3D | null = null
+
+    protected createActor(descriptor: DirectionalLightDescriptor, args: UpdateArgs) {
+        const actor = new NodeActor(new DirectionalLight())
+        return actor
+    }
+
+    setLight(actor: NodeActor<DirectionalLight>, descriptor: DirectionalLightDescriptor, args: UpdateArgs) {
+        actor.object.color.set(descriptor.color)
+        actor.object.intensity = descriptor.intensity
+        actor.object.shadow.bias = descriptor.bias
+        actor.object.shadow.normalBias = descriptor.normalBias
+
+        const mapSize = descriptor.mapSize
+        actor.object.shadow.mapSize.set(mapSize.x, mapSize.y)
+        if (actor.object.shadow.mapPass) {
+            actor.object.shadow.mapPass.setSize(mapSize.x, mapSize.y)
+            actor.object.shadow.mapPass.texture.needsUpdate = true
+        }
+        if (actor.object.shadow.map) {
+            actor.object.shadow.map.setSize(mapSize.x, mapSize.y)
+            actor.object.shadow.map.texture.needsUpdate = true
+        }
+
+        const camera = descriptor.camera
+        actor.object.shadow.camera.near = camera.near
+        actor.object.shadow.camera.far = camera.far
+        actor.object.shadow.camera.left = camera.left
+        actor.object.shadow.camera.right = camera.right
+        actor.object.shadow.camera.top = camera.top
+        actor.object.shadow.camera.bottom = camera.bottom
+        actor.object.shadow.camera.updateProjectionMatrix()
+    }
+
+    setTarget(actor: NodeActor<DirectionalLight>, descriptor: DirectionalLightDescriptor, args: UpdateArgs) {
+        let targetValue = descriptor.target
+        if (targetValue === '') {
+            const target = new Object3D()
+            target.position.copy(actor.object.target.position)
+            actor.object.target = target
+        } else {
+            const target = Descriptor.get<Descriptor>(targetValue)
+            if (target !== null) {
+                const targetActor = this.graphics.getActor<NodeActor>(target, args)
+                if (targetActor instanceof NodeActor) {
+                    actor.object.target = targetActor.object
+                } else {
+                    actor.object.target = new Object3D()
+                }
+            } else {
+                actor.object.target = new Object3D()
+            }
+
+        }
+
+    }
+
+    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)
+    }
+
+    free(descriptor: DirectionalLightDescriptor, args: UpdateArgs) {
+        const actor = this.getActor<NodeActor<DirectionalLight>>(descriptor, args)
+        actor.object.dispose()
+        super.free(descriptor, args)
+    }
+
+    pickup(descriptor: DirectionalLightDescriptor, args: UpdateArgs, result: PickupObject[]) { }
+}
+NodeInterpreter.register(DirectionalLightInterpreter)
+
+export { DirectionalLightInterpreter }

package/src/interpreter/light/HemisphereLightInterpreter.ts

@@ -0,0 +1,32 @@
+import { HemisphereLight } from "three";
+import { PickupObject, UpdateArgs } from "@vyr/engine";
+import { NodeInterpreter } from "../NodeInterpreter";
+import { HemisphereLightDescriptor } from "../../descriptor";
+import { NodeActor } from "../../actor";
+
+class HemisphereLightInterpreter extends NodeInterpreter {
+    static type = HemisphereLightDescriptor.type
+
+    protected createActor(descriptor: HemisphereLightDescriptor, args: UpdateArgs) {
+        const actor = new NodeActor(new HemisphereLight())
+        return actor
+    }
+
+    setLight(actor: NodeActor<HemisphereLight>, descriptor: HemisphereLightDescriptor, args: UpdateArgs) {
+        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)
+    }
+
+    pickup(descriptor: HemisphereLightDescriptor, args: UpdateArgs, result: PickupObject[]) { }
+}
+NodeInterpreter.register(HemisphereLightInterpreter)
+
+
+export { HemisphereLightInterpreter }

package/src/interpreter/light/PointLightInterpreter.ts

@@ -0,0 +1,46 @@
+import { PointLight } from "three";
+import { PickupObject, UpdateArgs } from "@vyr/engine";
+import { NodeInterpreter } from "../NodeInterpreter";
+import { PointLightDescriptor } from "../../descriptor";
+import { NodeActor } from "../../actor";
+
+class PointLightInterpreter extends NodeInterpreter {
+    static type = PointLightDescriptor.type
+
+    protected createActor(descriptor: PointLightDescriptor, args: UpdateArgs) {
+        const actor = new NodeActor(new PointLight())
+        return actor
+    }
+
+    setLight(actor: NodeActor<PointLight>, descriptor: PointLightDescriptor, args: UpdateArgs) {
+        actor.object.color.set(descriptor.color)
+        actor.object.intensity = descriptor.intensity
+        actor.object.decay = descriptor.decay
+        actor.object.distance = descriptor.distance
+        actor.object.power = descriptor.power
+        const mapSize = descriptor.mapSize
+        const camera = descriptor.camera
+        actor.object.shadow.mapSize.set(mapSize.x, mapSize.y)
+        actor.object.shadow.camera.near = camera.near
+        actor.object.shadow.camera.far = camera.far
+    }
+
+
+    update(descriptor: PointLightDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<NodeActor<PointLight>>(descriptor, args)
+        this.setLight(actor, descriptor, args)
+    }
+
+    free(descriptor: PointLightDescriptor, args: UpdateArgs) {
+        const actor = this.getActor<NodeActor<PointLight>>(descriptor, args)
+        actor.object.dispose()
+        super.free(descriptor, args)
+    }
+
+    pickup(descriptor: PointLightDescriptor, args: UpdateArgs, result: PickupObject[]) { }
+}
+NodeInterpreter.register(PointLightInterpreter)
+
+
+export { PointLightInterpreter }

package/src/interpreter/light/RectAreaLightInterpreter.ts

@@ -0,0 +1,34 @@
+import { RectAreaLight } from "three";
+import { PickupObject, UpdateArgs } from "@vyr/engine";
+import { NodeInterpreter } from "../NodeInterpreter";
+import { RectAreaLightDescriptor } from "../../descriptor";
+import { NodeActor } from "../../actor";
+
+class RectAreaLightInterpreter extends NodeInterpreter {
+    static type = RectAreaLightDescriptor.type
+
+    protected createActor(descriptor: RectAreaLightDescriptor, args: UpdateArgs) {
+        const actor = new NodeActor(new RectAreaLight())
+        return actor
+    }
+
+    setLight(actor: NodeActor<RectAreaLight>, descriptor: RectAreaLightDescriptor, args: UpdateArgs) {
+        actor.object.color.set(descriptor.color)
+        actor.object.intensity = descriptor.intensity
+        actor.object.width = descriptor.width
+        actor.object.height = descriptor.height
+        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)
+    }
+
+    pickup(descriptor: RectAreaLightDescriptor, args: UpdateArgs, result: PickupObject[]) { }
+}
+NodeInterpreter.register(RectAreaLightInterpreter)
+
+
+export { RectAreaLightInterpreter }

package/src/interpreter/light/SpotLightInterpreter.ts

@@ -0,0 +1,68 @@
+import { Object3D, SpotLight } from "three";
+import { Descriptor, PickupObject, UpdateArgs } from "@vyr/engine";
+import { NodeInterpreter } from "../NodeInterpreter";
+import { SpotLightDescriptor } from "../../descriptor";
+import { NodeActor } from "../../actor";
+
+class SpotLightInterpreter extends NodeInterpreter {
+    static type = SpotLightDescriptor.type
+
+    protected createActor(descriptor: SpotLightDescriptor, args: UpdateArgs) {
+        const actor = new NodeActor(new SpotLight())
+        return actor
+    }
+
+    setLight(actor: NodeActor<SpotLight>, descriptor: SpotLightDescriptor, args: UpdateArgs) {
+        actor.object.color.set(descriptor.color)
+        actor.object.intensity = descriptor.intensity
+        actor.object.angle = descriptor.angle
+        actor.object.decay = descriptor.decay
+        actor.object.distance = descriptor.distance
+        actor.object.penumbra = descriptor.penumbra
+        actor.object.power = descriptor.power
+        const mapSize = descriptor.mapSize
+        const camera = descriptor.camera
+        actor.object.shadow.mapSize.set(mapSize.x, mapSize.y)
+        actor.object.shadow.camera.near = camera.near
+        actor.object.shadow.camera.far = camera.far
+    }
+
+    setTarget(actor: NodeActor<SpotLight>, descriptor: SpotLightDescriptor, args: UpdateArgs) {
+        if (descriptor.target === '') {
+            const target = new Object3D()
+            target.position.copy(actor.object.target.position)
+            actor.object.target = target
+        } else {
+            const target = Descriptor.get<Descriptor>(descriptor.target)
+            if (target !== null) {
+                const targetActor = this.graphics.getActor<NodeActor>(target, args)
+                if (targetActor instanceof NodeActor) {
+                    actor.object.target = targetActor.object
+                } else {
+                    actor.object.target = new Object3D()
+                }
+            } else {
+                actor.object.target = new Object3D()
+            }
+        }
+    }
+
+    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)
+    }
+
+    free(descriptor: SpotLightDescriptor, args: UpdateArgs) {
+        const actor = this.getActor<NodeActor<SpotLight>>(descriptor, args)
+        actor.object.dispose()
+        super.free(descriptor, args)
+    }
+
+    pickup(descriptor: SpotLightDescriptor, args: UpdateArgs, result: PickupObject[]) { }
+}
+NodeInterpreter.register(SpotLightInterpreter)
+
+
+export { SpotLightInterpreter }

package/src/interpreter/material/MaterialInterpreter.ts

@@ -0,0 +1,34 @@
+import { Material } from "three";
+import { Interpreter, UpdateArgs } from "@vyr/engine";
+import { MaterialDescriptor } from "../../descriptor";
+import { MaterialActor } from "../../actor";
+import { material as _material } from "../../utils";
+
+class MaterialInterpreter extends Interpreter {
+    static type = MaterialDescriptor.type
+
+    setProperty(material: Material, descriptor: MaterialDescriptor) {
+        material.alphaTest = descriptor.alphaTest
+        material.transparent = descriptor.transparent
+        material.colorWrite = descriptor.colorWrite
+        material.depthTest = descriptor.depthTest
+        material.depthWrite = descriptor.depthrWrite
+        //@ts-ignore
+        material.side = descriptor.side
+        //@ts-ignore
+        material.depthFunc = descriptor.depthFunc
+        //@ts-ignore
+        material.blending = descriptor.blending
+        material.vertexColors = descriptor.vertexColors
+        material.needsUpdate = true
+    }
+
+    free(descriptor: MaterialDescriptor, args: UpdateArgs) {
+        const actor = this.getActor<MaterialActor>(descriptor, args)
+        actor.object.dispose()
+        super.free(descriptor, args)
+    }
+}
+Interpreter.register(MaterialInterpreter)
+
+export { MaterialInterpreter }

package/src/interpreter/material/MeshBasicMaterialInterpreter.ts

@@ -0,0 +1,43 @@
+import { MeshBasicMaterial } from "three";
+import { UpdateArgs } from "@vyr/engine";
+import { MaterialInterpreter } from './MaterialInterpreter'
+import { MeshBasicMaterialDescriptor } from "../../descriptor";
+import { MaterialActor } from "../../actor";
+import { texture } from "../../utils";
+
+class MeshBasicMaterialInterpreter extends MaterialInterpreter {
+    static type = MeshBasicMaterialDescriptor.type
+
+    protected createActor(descriptor: MeshBasicMaterialDescriptor, args: UpdateArgs) {
+        const actor = new MaterialActor(new MeshBasicMaterial())
+        return actor
+    }
+
+    setProperty(material: MeshBasicMaterial, descriptor: MeshBasicMaterialDescriptor) {
+        super.setProperty(material, descriptor)
+
+        material.color.setStyle(descriptor.color.value)
+        material.opacity = descriptor.color.opacity
+        material.reflectivity = descriptor.reflectivity
+        material.refractionRatio = descriptor.refractionRatio
+        material.lightMapIntensity = descriptor.lightMapIntensity
+        //@ts-ignore
+        material.combine = descriptor.combine
+        material.fog = descriptor.fog
+        material.wireframe = descriptor.wireframe
+    }
+
+    update(descriptor: MeshBasicMaterialDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<MaterialActor<MeshBasicMaterial>>(descriptor, args)
+        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)
+    }
+}
+MaterialInterpreter.register(MeshBasicMaterialInterpreter)
+
+export { MeshBasicMaterialInterpreter }

package/src/interpreter/material/MeshPhongMaterialInterpreter.ts

@@ -0,0 +1,63 @@
+import { MeshPhongMaterial } from "three";
+import { UpdateArgs } from "@vyr/engine";
+import { MaterialInterpreter } from "./MaterialInterpreter";
+import { MeshPhongMaterialDescriptor } from "../../descriptor";
+import { MaterialActor } from "../../actor";
+import { texture } from "../../utils";
+
+class MeshPhongMaterialInterpreter extends MaterialInterpreter {
+    static type = MeshPhongMaterialDescriptor.type
+
+    protected createActor(descriptor: MeshPhongMaterialDescriptor, args: UpdateArgs) {
+        const actor = new MaterialActor(new MeshPhongMaterial())
+        return actor
+    }
+
+    setProperty(material: MeshPhongMaterial, descriptor: MeshPhongMaterialDescriptor) {
+        super.setProperty(material, descriptor)
+
+        material.color.setStyle(descriptor.color.value)
+        material.opacity = descriptor.color.opacity
+        material.emissive.setStyle(descriptor.emissive)
+        material.specular.setStyle(descriptor.specular)
+        material.reflectivity = descriptor.reflectivity
+        material.refractionRatio = descriptor.refractionRatio
+        material.lightMapIntensity = descriptor.lightMapIntensity
+        //@ts-ignore
+        material.combine = descriptor.combine
+
+        material.aoMapIntensity = descriptor.aoMapIntensity
+        material.bumpScale = descriptor.bumpScale
+        material.displacementScale = descriptor.displacementScale
+        material.displacementBias = descriptor.displacementBias
+        material.emissiveIntensity = descriptor.emissiveIntensity
+        material.envMapRotation.set(descriptor.envMapRotation.x, descriptor.envMapRotation.y, descriptor.envMapRotation.z)
+        material.lightMapIntensity = descriptor.lightMapIntensity
+        //@ts-ignore
+        material.normalMapType = descriptor.normalMapType
+        material.reflectivity = descriptor.reflectivity
+        material.refractionRatio = descriptor.refractionRatio
+        material.shininess = descriptor.shininess
+        material.flatShading = descriptor.flatShading
+        material.fog = descriptor.fog
+        material.wireframe = descriptor.wireframe
+    }
+
+    update(descriptor: MeshPhongMaterialDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<MaterialActor<MeshPhongMaterial>>(descriptor, args)
+        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)
+    }
+}
+MaterialInterpreter.register(MeshPhongMaterialInterpreter)
+
+export { MeshPhongMaterialInterpreter }