@vyr/three 0.0.1

package/src/interpreter/InstancedMeshInterpreter.ts

@@ -0,0 +1,76 @@
+import { Color, InstancedMesh, Matrix4, Object3D } from 'three'
+import { DatasetDescriptor, UpdateArgs } from "@vyr/engine";
+import { InstancedMeshDescriptor, InstancedSetting } from "../descriptor";
+import { PickupNode } from './NodeInterpreter';
+import { MeshInterpreter } from "./MeshInterpreter";
+import { NodeActor } from '../actor';
+import { material, geometry, collectionPickupResult } from '../utils';
+
+class InstancedMeshInterpreter extends MeshInterpreter {
+    static type = InstancedMeshDescriptor.type
+
+    readonly wrapper!: Object3D
+    instancedMesh!: InstancedMesh
+    count = -1
+
+    createActor(descriptor: InstancedMeshDescriptor, args: UpdateArgs) {
+        const actor = new NodeActor(new Object3D())
+        //@ts-ignore
+        this.wrapper = new Object3D()
+        actor.object.add(this.wrapper)
+        return actor
+    }
+
+    updateInstanceMesh(setting: InstancedSetting[], instance: InstancedMesh) {
+        const color = new Color()
+        const matrix = new Matrix4()
+
+        for (let i = 0; i < setting.length; i++) {
+            const setItem = setting[i]
+            color.setStyle(setItem.color)
+            matrix.fromArray(setItem.matrix)
+            instance.setMatrixAt(i, matrix)
+            instance.setColorAt(i, color)
+        }
+
+        instance.instanceMatrix.needsUpdate = true
+        if (instance.instanceColor) instance.instanceColor.needsUpdate = true
+    }
+
+    getInstancedMesh(descriptor: InstancedMeshDescriptor, args: UpdateArgs, setting: InstancedSetting[]) {
+        const instancedMesh = new InstancedMesh(geometry.defaultGeometry(), material.defaultMaterial(), setting.length)
+        return instancedMesh
+    }
+
+    setInstancedMesh(descriptor: InstancedMeshDescriptor, args: UpdateArgs) {
+        const setting = DatasetDescriptor.getCollection<InstancedSetting>(descriptor.setting)
+        if (this.count !== setting.length) {
+            this.count = setting.length
+            this.wrapper.clear()
+            if (this.instancedMesh) this.instancedMesh.dispose()
+            this.instancedMesh = this.getInstancedMesh(descriptor, args, setting)
+            this.wrapper.add(this.instancedMesh)
+        }
+        this.updateInstanceMesh(setting, this.instancedMesh)
+    }
+
+    update(descriptor: InstancedMeshDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        this.setInstancedMesh(descriptor, args)
+        this.instancedMesh.geometry = geometry.getGeometry(descriptor.geometry, this.graphics, args)
+        this.instancedMesh.material = material.getMaterial(descriptor.material, this.graphics, args)
+    }
+
+    free(descriptor: InstancedMeshDescriptor, args: UpdateArgs) {
+        this.instancedMesh.dispose()
+        super.free(descriptor, args)
+    }
+
+    pickup(descriptor: InstancedMeshDescriptor, args: UpdateArgs, result: PickupNode[]) {
+        if (descriptor.visible === false) return
+        collectionPickupResult(this.wrapper, true, descriptor, result)
+    }
+}
+MeshInterpreter.register(InstancedMeshInterpreter)
+
+export { InstancedMeshInterpreter }

package/src/interpreter/MeshInterpreter.ts

@@ -0,0 +1,25 @@
+import { Mesh } from "three";
+import { UpdateArgs } from "@vyr/engine";
+import { MeshDescriptor } from "../descriptor";
+import { NodeInterpreter } from "./NodeInterpreter";
+import { NodeActor } from "../actor";
+import { geometry, material } from "../utils";
+
+class MeshInterpreter extends NodeInterpreter {
+    static type = MeshDescriptor.type
+
+    protected createActor(descriptor: MeshDescriptor, args: UpdateArgs): NodeActor {
+        const actor = new NodeActor(new Mesh(geometry.defaultGeometry(), material.defaultMaterial()))
+        return actor
+    }
+
+    update(descriptor: MeshDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<NodeActor<Mesh>>(descriptor, args)
+        actor.object.geometry = geometry.getGeometry(descriptor.geometry, this.graphics, args)
+        actor.object.material = material.getMaterial(descriptor.material, this.graphics, args)
+    }
+}
+NodeInterpreter.register(MeshInterpreter)
+
+export { MeshInterpreter }

package/src/interpreter/ModelInterpreter.ts

@@ -0,0 +1,61 @@
+import { Object3D } from 'three'
+import { Asset, Descriptor, UpdateArgs } from "@vyr/engine";
+import { ModelDescriptor } from "../descriptor";
+import { NodeInterpreter, PickupNode } from "./NodeInterpreter";
+import { NodeActor } from '../actor';
+import { collectionPickupResult, diaposeObject3D } from '../utils'
+
+class ModelInterpreter extends NodeInterpreter {
+    static type = ModelDescriptor.type
+
+    readonly wrapper!: Object3D
+    url = ''
+
+    protected createActor(descriptor: Descriptor, args: UpdateArgs) {
+        const actor = super.createActor(descriptor, args)
+        //@ts-ignore
+        this.wrapper = new Object3D()
+        actor.object.add(this.wrapper)
+        return actor
+    }
+
+    setModel(descriptor: ModelDescriptor, args: UpdateArgs) {
+
+        if (this.url !== descriptor.url) {
+            diaposeObject3D(this.wrapper)
+            this.wrapper.clear()
+
+            if (descriptor.url) {
+                this.url = descriptor.url
+                const currentUrl = `${descriptor.url}?${descriptor.uuid}`
+                const model = Asset.get<Object3D>(currentUrl)
+                this.wrapper.add(model)
+            } else {
+                this.url = ''
+            }
+        }
+
+        this.wrapper.traverse(sub => {
+            sub.castShadow = descriptor.castShadow
+            sub.receiveShadow = descriptor.receiveShadow
+        })
+    }
+
+    update(descriptor: ModelDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        this.setModel(descriptor, args)
+    }
+
+    free(descriptor: ModelDescriptor, args: UpdateArgs) {
+        diaposeObject3D(this.wrapper)
+        super.free(descriptor, args)
+    }
+
+    pickup(descriptor: ModelDescriptor, args: UpdateArgs, result: PickupNode[]) {
+        if (descriptor.visible === false) return
+        collectionPickupResult(this.wrapper, true, descriptor, result)
+    }
+}
+NodeInterpreter.register(ModelInterpreter)
+
+export { ModelInterpreter }

package/src/interpreter/NodeInterpreter.ts

@@ -0,0 +1,65 @@
+import { Object3D, Intersection } from "three";
+import { Descriptor, Interpreter, NodeDescriptor, PickupObject, UpdateArgs } from "@vyr/engine";
+import { NodeActor } from "../actor";
+import { collectionPickupResult } from "../utils";
+
+interface PickupNode extends PickupObject {
+    minDistance: number
+    intersection: Intersection<Object3D>[]
+}
+
+class NodeInterpreter extends Interpreter {
+    static type = NodeDescriptor.type
+
+    protected createActor(descriptor: Descriptor, args: UpdateArgs) {
+        const actor = new NodeActor(new Object3D())
+        return actor
+    }
+
+    setProperty(actor: NodeActor, descriptor: NodeDescriptor, args: UpdateArgs) {
+        actor.object.layers.set(descriptor.layer)
+        actor.object.visible = descriptor.visible
+        actor.object.renderOrder = descriptor.renderOrder
+        actor.object.castShadow = descriptor.castShadow
+        actor.object.receiveShadow = descriptor.receiveShadow
+    }
+
+    setTransform(actor: NodeActor, descriptor: NodeDescriptor, args: UpdateArgs) {
+        const scale = descriptor.scale
+        const position = descriptor.position
+        const rotation = descriptor.rotation
+        actor.object.scale.set(scale.x, scale.y, scale.z)
+        actor.object.position.set(position.x, position.y, position.z)
+        actor.object.rotation.set(rotation.x, rotation.y, rotation.z)
+    }
+
+    update(descriptor: NodeDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<NodeActor>(descriptor, args)
+        this.setProperty(actor, descriptor, args)
+        this.setTransform(actor, descriptor, args)
+    }
+
+    mount(descriptor: NodeDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
+        const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor, args)
+        const actor = this.getActor<NodeActor>(descriptor, args)
+        parenActor.add(actor)
+    }
+
+    unmount(descriptor: NodeDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const parenActor = parentInterpreter.getActor<NodeActor>(parentDescriptor, args)
+        const actor = this.getActor<NodeActor>(descriptor, args)
+        parenActor.remove(actor)
+        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+    }
+
+    pickup(descriptor: NodeDescriptor, args: UpdateArgs, result: PickupNode[]) {
+        if (descriptor.visible === false) return
+        const actor = this.getActor<NodeActor>(descriptor, args)
+        collectionPickupResult(actor.object, false, descriptor, result)
+    }
+}
+Interpreter.register(NodeInterpreter)
+
+export { PickupNode, NodeInterpreter }

package/src/interpreter/OrbitControllerInterpreter.ts

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

package/src/interpreter/OrthographicCameraInterpreter.ts

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

package/src/interpreter/ParticleInterpreter.ts

@@ -0,0 +1,221 @@
+import {
+  BufferGeometry,
+  BufferAttribute,
+  Points,
+  WebGLProgramParametersWithUniforms,
+  WebGLRenderer,
+  DataTexture,
+  PointsMaterial,
+  RGBAFormat,
+  FloatType,
+  ClampToEdgeWrapping,
+  LinearFilter,
+  CatmullRomCurve3,
+  Vector3,
+} from "three";
+import { DatasetDescriptor, UpdateArgs } from "@vyr/engine";
+import { ParticleDescriptor } from "../descriptor";
+import { NodeInterpreter } from "./NodeInterpreter";
+import { NodeActor } from "../actor";
+import { randomRange, texture } from "../utils";
+
+class ParticleInterpreter extends NodeInterpreter {
+  static type = ParticleDescriptor.type;
+
+  private _duration = 0;
+  private _geometry = new BufferGeometry();
+  private _material = new PointsMaterial();
+  private _tracRadio = { value: 0 };
+  private _trackTexture = { value: new DataTexture() };
+  uptime = 0;
+
+  protected createActor(descriptor: ParticleDescriptor, args: UpdateArgs) {
+    const actor = new NodeActor(new Points(this._geometry, this._material));
+    return actor;
+  }
+  private _createTypeArray(trackData: number[][], count: number) {
+    const typeArray = new Float32Array(count * 4);
+
+    const points: Vector3[] = [];
+    for (const point of trackData) {
+      points.push(new Vector3(point[0], point[1], point[2]));
+    }
+
+    const curve = new CatmullRomCurve3(points, false, "catmullrom", 0);
+    for (let i = 0; i < count; i++) {
+      const point = curve.getPointAt(i / count);
+      typeArray[i * 4] = point.x; // R
+      typeArray[i * 4 + 1] = point.y; // G
+      typeArray[i * 4 + 2] = point.z; // B
+      typeArray[i * 4 + 3] = 1.0; // A
+    }
+
+    return typeArray;
+  }
+  private _decorateShader(params: WebGLProgramParametersWithUniforms, renderer: WebGLRenderer) {
+    const precode = [
+      "attribute vec3 trackScale;",
+      "attribute vec3 trackRotation;",
+      "attribute vec3 trackOffset;",
+      "attribute float vSize;",
+      "uniform sampler2D trackTexture;", // 位置纹理
+      "uniform float tracRadio;",
+
+      // 从欧拉角创建旋转矩阵的函数
+      "mat4 rotationMatrixFromEuler(vec3 euler) {",
+      "  float cx = cos(euler.x);",
+      "  float sx = sin(euler.x);",
+      "  float cy = cos(euler.y);",
+      "  float sy = sin(euler.y);",
+      "  float cz = cos(euler.z);",
+      "  float sz = sin(euler.z);",
+      "  return mat4(",
+      "    cy * cz, cx * sz + sx * sy * cz, sx * sz - cx * sy * cz, 0.0,",
+      "    -cy * sz, cx * cz - sx * sy * sz, sx * cz + cx * sy * sz, 0.0,",
+      "    sy, -sx * cy, cx * cy, 0.0,",
+      "    0.0, 0.0, 0.0, 1.0",
+      "  );",
+      "}",
+
+      // 从纹理采样位置的函数
+      "vec3 getPositionFromTexture(float u) {",
+      "  vec2 uv = vec2(u, 0.5);", // 水平用传入的u，垂直固定0.5
+      "  vec4 texel = texture2D(trackTexture, uv);",
+      "  return texel.rgb;",
+      "}",
+    ].join("\n");
+
+    // 在着色器开头插入precode
+    params.vertexShader = precode + "\n" + params.vertexShader;
+
+    // 然后替换begin_vertex部分
+    params.vertexShader = params.vertexShader.replace(
+      "#include <begin_vertex>",
+      [
+        "#include <begin_vertex>",
+        "",
+        "// 从纹理获取位置",
+        "vec3 texturePosition = getPositionFromTexture(tracRadio);",
+        "",
+        "// 应用旋转变换",
+        "mat4 rotationMatrix = rotationMatrixFromEuler(trackRotation);",
+        "transformed = (rotationMatrix * vec4(texturePosition, 1.0)).xyz;",
+        "",
+        "// 应用缩放变换",
+        "transformed *= trackScale;",
+        "",
+        "// 应用偏移变换",
+        "transformed += trackOffset;",
+      ].join("\n")
+    ).replace(
+      'gl_PointSize = size;',
+      'gl_PointSize = vSize * size;'
+    );
+  }
+  private _setTrackMap(descriptor: ParticleDescriptor, args: UpdateArgs) {
+    this.clear();
+
+    const trackData = DatasetDescriptor.getCollection<number[]>(descriptor.track);
+    const count = Math.ceil(trackData.length / 512) * 512;
+    const typeArray = this._createTypeArray(trackData, count);
+    this._trackTexture.value = new DataTexture(typeArray, count, 1, RGBAFormat, FloatType);
+    this._trackTexture.value.wrapS = ClampToEdgeWrapping;
+    this._trackTexture.value.wrapT = ClampToEdgeWrapping;
+    this._trackTexture.value.minFilter = LinearFilter;
+    this._trackTexture.value.magFilter = LinearFilter;
+    this._trackTexture.value.generateMipmaps = false;
+    this._trackTexture.value.needsUpdate = true;
+
+    this._material.onBeforeCompile = (params, renderer) => {
+      params.uniforms.trackTexture = this._trackTexture;
+      params.uniforms.tracRadio = this._tracRadio;
+      this._decorateShader(params, renderer);
+    };
+    this.graphics.engine.listen("beforeRender", this._updateRadio);
+  }
+  private _updateMaterial(descriptor: ParticleDescriptor, args: UpdateArgs) {
+    this._setTrackMap(descriptor, args);
+    texture.setMap(this._material, "map", descriptor, this.graphics, args);
+    texture.setMap(this._material, "alphaMap", descriptor, this.graphics, args);
+    this._material.alphaTest = descriptor.alphaTest;
+    this._material.transparent = descriptor.transparent;
+    this._material.colorWrite = descriptor.colorWrite;
+    this._material.depthTest = descriptor.depthTest;
+    this._material.depthWrite = descriptor.depthrWrite;
+    //@ts-ignore
+    this._material.side = descriptor.side
+    //@ts-ignore
+    this._material.depthFunc = descriptor.depthFunc
+    //@ts-ignore
+    this._material.blending = descriptor.blending
+    this._material.vertexColors = descriptor.vertexColors;
+    this._material.color.setStyle(descriptor.color.value);
+    this._material.opacity = descriptor.color.opacity;
+    this._material.size = 1;
+    this._material.sizeAttenuation = descriptor.sizeAttenuation;
+    this._material.fog = descriptor.fog;
+    this._material.needsUpdate = true;
+  }
+  private _updateGeometry(descriptor: ParticleDescriptor) {
+    const positions: number[] = [];
+    const offsets: number[] = [];
+    const rotations: number[] = [];
+    const scales: number[] = [];
+    const sizes: number[] = []
+
+    for (let i = 0; i < descriptor.count; i++) {
+      positions.push(0, 0, 0);
+
+      const offsetX = randomRange(descriptor.minTrackOffset.x, descriptor.maxTrackOffset.x);
+      const offsetY = randomRange(descriptor.minTrackOffset.y, descriptor.maxTrackOffset.y);
+      const offsetZ = randomRange(descriptor.minTrackOffset.z, descriptor.maxTrackOffset.z);
+      offsets.push(offsetX, offsetY, offsetZ);
+
+      const rotationX = randomRange(descriptor.minTrackRotation.x, descriptor.maxTrackRotation.x);
+      const rotationY = randomRange(descriptor.minTrackRotation.y, descriptor.maxTrackRotation.y);
+      const rotationZ = randomRange(descriptor.minTrackRotation.z, descriptor.maxTrackRotation.z);
+      rotations.push(rotationX, rotationY, rotationZ);
+
+      const scaleX = randomRange(descriptor.minTrackScale.x, descriptor.maxTrackScale.x);
+      const scaleY = randomRange(descriptor.minTrackScale.y, descriptor.maxTrackScale.y);
+      const scaleZ = randomRange(descriptor.minTrackScale.z, descriptor.maxTrackScale.z);
+      scales.push(scaleX, scaleY, scaleZ);
+
+      const size = randomRange(descriptor.minSize, descriptor.maxSize)
+      sizes.push(size)
+    }
+    const geometry = new BufferGeometry()
+    geometry.setAttribute("position", new BufferAttribute(new Float32Array(positions), 3));
+    geometry.setAttribute("trackOffset", new BufferAttribute(new Float32Array(offsets), 3));
+    geometry.setAttribute("trackRotation", new BufferAttribute(new Float32Array(rotations), 3));
+    geometry.setAttribute("trackScale", new BufferAttribute(new Float32Array(scales), 3));
+    geometry.setAttribute('vSize', new BufferAttribute(new Float32Array(sizes), 1));
+
+    this._geometry.copy(geometry)
+  }
+  private _updateRadio = (args: UpdateArgs) => {
+    this.uptime += args.delta;
+    const currentTime = this.uptime % this._duration;
+    this._tracRadio.value = currentTime / this._duration;
+  };
+
+  update(descriptor: ParticleDescriptor, args: UpdateArgs) {
+    super.update(descriptor, args);
+    this._duration = descriptor.duration;
+    this._updateGeometry(descriptor);
+    this._updateMaterial(descriptor, args);
+  }
+
+  clear() {
+    this.graphics.engine.unlisten("beforeRender", this._updateRadio);
+    this._trackTexture.value.dispose();
+  }
+
+  free(descriptor: ParticleDescriptor, args: UpdateArgs) {
+    this.clear();
+    super.free(descriptor, args);
+  }
+}
+NodeInterpreter.register(ParticleInterpreter);
+
+export { ParticleInterpreter };

package/src/interpreter/PassInterpreter.ts

@@ -0,0 +1,43 @@
+// import { Descriptor, Interpreter, UpdateArgs } from "@vyr/engine";
+// import { PassDescriptor } from '../descriptor/PassDescriptor'
+// import { ComposerServiceActor, PassActor } from "../actor"
+
+// class PassInterpreter extends Interpreter {
+//     static type = PassDescriptor.type
+
+//     protected createActor(descriptor: PassDescriptor, args: UpdateArgs) {
+//         const actor = new PassActor(descriptor)
+//         return actor
+//     }
+
+//     update(descriptor: PassDescriptor, args: UpdateArgs) {
+//         super.update(descriptor, args)
+//         const actor = this.getActor<PassActor>(descriptor, args)
+//         actor.update(descriptor)
+//     }
+
+//     mount(descriptor: PassDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+//         super.mount(descriptor, args, parentInterpreter, parentDescriptor)
+//         const parenActor = parentInterpreter.getActor<ComposerServiceActor>(parentDescriptor, args)
+//         const actor = this.getActor<PassActor>(descriptor, args)
+//         parenActor.add(actor)
+//     }
+
+//     unmount(descriptor: PassDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+//         const parenActor = parentInterpreter.getActor<ComposerServiceActor>(parentDescriptor, args)
+//         const actor = this.getActor<PassActor>(descriptor, args)
+//         parenActor.remove(actor)
+
+//         super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+//     }
+
+//     free(descriptor: PassDescriptor, args: UpdateArgs) {
+//         const actor = this.getActor<PassActor>(descriptor, args)
+//         actor.dispose()
+//         super.free(descriptor, args)
+//     }
+// }
+// Interpreter.register(PassInterpreter)
+
+
+// export { PassInterpreter }

package/src/interpreter/PerspectiveCameraInterpreter.ts

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

package/src/interpreter/PointsInterpreter.ts

@@ -0,0 +1,61 @@
+import { BufferGeometry, Points, Material, PointsMaterial } from "three";
+import { Asset, UpdateArgs } from "@vyr/engine";
+import { PointsDescriptor } from "../descriptor";
+import { NodeInterpreter } from "./NodeInterpreter";
+import { GeometryActor, MaterialActor, NodeActor } from "../actor";
+
+class PointsInterpreter extends NodeInterpreter {
+    private static _geometry: BufferGeometry | null = null
+    private static _material: Material | null = null
+    static get geometry() {
+        if (this._geometry === null) {
+            this._geometry = new BufferGeometry()
+        }
+        return this._geometry
+    }
+    static get material() {
+        if (this._material === null) {
+            this._material = new PointsMaterial()
+        }
+        return this._material
+    }
+
+    static type = PointsDescriptor.type
+    
+    protected createActor(descriptor: PointsDescriptor, args: UpdateArgs) {
+        const actor = new NodeActor(new Points())
+        return actor
+    }
+
+    getGeometry(descriptor: PointsDescriptor, args: UpdateArgs) {
+        const geometryDescriptor = Asset.get(descriptor.geometry)
+        if (geometryDescriptor === null) return PointsInterpreter.geometry
+
+        const interpreter = this.graphics.getInterpreter(geometryDescriptor)
+        const actor = interpreter.getActor<GeometryActor<BufferGeometry>>(geometryDescriptor, args)
+        return actor.object instanceof BufferGeometry ? actor.object : PointsInterpreter.geometry
+    }
+
+    useMaterial(material: string, args: UpdateArgs) {
+        const materialDescriptor = Asset.get(material)
+        if (materialDescriptor === null) return PointsInterpreter.material
+
+        const interpreter = this.graphics.getInterpreter(materialDescriptor)
+        const actor = interpreter.getActor<MaterialActor<Material>>(materialDescriptor, args)
+        return actor.object instanceof Material ? actor.object : PointsInterpreter.material
+    }
+
+    getMaterial(descriptor: PointsDescriptor, args: UpdateArgs) {
+        return this.useMaterial(descriptor.material, args)
+    }
+
+    update(descriptor: PointsDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<NodeActor<Points>>(descriptor, args)
+        actor.object.geometry = this.getGeometry(descriptor, args)
+        actor.object.material = this.getMaterial(descriptor, args)
+    }
+}
+NodeInterpreter.register(PointsInterpreter)
+
+export { PointsInterpreter }