@vyr/three 0.0.1

package/src/interpreter/SceneServiceInterpreter.ts

@@ -0,0 +1,119 @@
+import { Camera, PerspectiveCamera, Raycaster, Vector2, } from 'three'
+import { CameraDescriptor, Descriptor, HTMLActor, Interpreter, ServiceDescriptor, ServiceInterpreter, UpdateArgs } from '@vyr/engine'
+import { SceneServiceDescriptor } from '../descriptor'
+import { NodeActor, SceneServiceActor } from '../actor'
+import { PickupNode } from './NodeInterpreter'
+
+class SceneServiceInterpreter extends ServiceInterpreter {
+    static type = SceneServiceDescriptor.type
+
+    static ray = new Raycaster()
+    static direcation = new Vector2()
+
+    private _unlisten = -1
+    protected createActor(descriptor: SceneServiceDescriptor, args: UpdateArgs) {
+        const actor = new SceneServiceActor(descriptor.uuid)
+        return actor
+    }
+
+    protected setSize(actor: SceneServiceActor) {
+        const rect = actor.pipeline.domElement.getBoundingClientRect()
+        actor.pipeline.setSize(rect.width, rect.height)
+        actor.screenPipeline.setSize(rect.width, rect.height)
+        return rect
+    }
+    protected resize = () => {
+        const descriptor = Descriptor.get<Descriptor>(this.unit.uuid)
+        const actor = this.getActor<SceneServiceActor>(descriptor, { delta: 0 })
+        this.setSize(actor)
+    }
+
+    update(descriptor: SceneServiceDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+
+        const actor = this.getActor<SceneServiceActor>(descriptor, args)
+        actor.update(descriptor, args)
+
+        this.resize()
+        actor.pipeline.shadowMap.enabled = descriptor.shadowMap
+        actor.pipeline.shadowMap.autoUpdate = descriptor.autoUpdateShadowMap
+        //@ts-ignore
+        actor.pipeline.shadowMap.type = descriptor.shadowMapType
+        actor.pipeline.shadowMap.needsUpdate = true
+    }
+
+    mount(descriptor: SceneServiceDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
+
+        const actor = this.getActor<SceneServiceActor>(descriptor, args)
+        actor.clearStyleClass(actor.pipeline.domElement)
+
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor, args)
+        if (parenActor instanceof HTMLActor) parenActor.add(actor)
+
+        this._unlisten = this.graphics.engine.inputSystem.listen('resize', this.resize, { target: window })
+    }
+
+    unmount(descriptor: SceneServiceDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<SceneServiceActor>(descriptor, args)
+
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor, args)
+        parenActor.remove(actor)
+
+        this.graphics.engine.inputSystem.unlisten(this._unlisten)
+        this.resize()
+
+        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+    }
+
+    free(descriptor: SceneServiceDescriptor, args: UpdateArgs) {
+        const actor = this.getActor<SceneServiceActor>(descriptor, args)
+        actor.dispose()
+        super.free(descriptor, args)
+    }
+
+    clear(service: ServiceDescriptor, args: UpdateArgs): void {
+        const actor = this.getActor<SceneServiceActor>(service, args)
+        actor.pipeline.clear()
+    }
+
+    beforeRender(service: SceneServiceDescriptor, args: UpdateArgs) {
+        const actor = this.getActor<SceneServiceActor>(service, args)
+        actor.scene.updateMatrixWorld()
+    }
+
+    render(service: SceneServiceDescriptor, args: UpdateArgs) {
+        const cameraDescriptor = CameraDescriptor.get<CameraDescriptor>(this.graphics.scheduler.camera)
+        if (cameraDescriptor === null) return
+        const actor = this.getActor<SceneServiceActor>(service, args)
+
+        const cameraInterpreter = this.graphics.getInterpreter(cameraDescriptor)
+        const camera = cameraInterpreter.getActor<NodeActor<Camera>>(cameraDescriptor, args)
+        if (camera.object instanceof PerspectiveCamera) {
+            const aspect = actor.pipeline.domElement.clientWidth / actor.pipeline.domElement.clientHeight
+            if (aspect !== camera.object.aspect) {
+                camera.object.aspect = aspect
+                camera.object.updateProjectionMatrix()
+            }
+        }
+
+        actor.render(service, camera, args)
+    }
+
+    beforePickup(mouse: { x: number; y: number }, rect: DOMRect, args: UpdateArgs) {
+        const currentCamera = SceneServiceDescriptor.get<CameraDescriptor>(this.graphics.scheduler.camera)
+        const camera = this.graphics.getInterpreter(currentCamera).getActor<NodeActor<Camera>>(currentCamera, args)
+
+        SceneServiceInterpreter.direcation.x = (mouse.x / rect.width) * 2 - 1
+        SceneServiceInterpreter.direcation.y = -(mouse.y / rect.height) * 2 + 1
+
+        SceneServiceInterpreter.ray.setFromCamera(SceneServiceInterpreter.direcation, camera.object)
+    }
+
+    orderBy(result: PickupNode[]) {
+        result.sort((a, b) => a.minDistance - b.minDistance)
+    }
+}
+ServiceInterpreter.register(SceneServiceInterpreter)
+
+export { SceneServiceInterpreter }

package/src/interpreter/ServiceSchedulerInterpreter.ts

@@ -0,0 +1,23 @@
+import { AnimationMixer, Object3D } from 'three'
+import { ServiceSchedulerInterpreter as SchedulerInterpreter, ServiceSchedulerDescriptor, UpdateArgs } from '@vyr/engine'
+
+class ServiceSchedulerInterpreter extends SchedulerInterpreter {
+    readonly mixer = new AnimationMixer(new Object3D())
+
+    updateMixer = (args: UpdateArgs) => {
+        this.mixer.update(args.delta)
+    }
+
+    install(descriptor: ServiceSchedulerDescriptor, args: UpdateArgs) {
+        super.install(descriptor, args)
+        this.graphics.engine.listen('beforeRender', this.updateMixer)
+    }
+
+    uninstall(descriptor: ServiceSchedulerDescriptor, args: UpdateArgs) {
+        this.graphics.engine.unlisten('beforeRender', this.updateMixer)
+        super.uninstall(descriptor, args)
+    }
+}
+SchedulerInterpreter.register(ServiceSchedulerInterpreter)
+
+export { ServiceSchedulerInterpreter }

package/src/interpreter/SpriteInterpreter.ts

@@ -0,0 +1,45 @@
+import { Sprite, SpriteMaterial } from "three";
+import { Asset, UpdateArgs } from "@vyr/engine";
+import { SpriteDescriptor } from "../descriptor";
+import { NodeInterpreter } from "./NodeInterpreter";
+import { MaterialActor, NodeActor } from "../actor";
+
+class SpriteInterpreter extends NodeInterpreter {
+    private static _material: SpriteMaterial | null = null
+
+    static get material() {
+        if (this._material === null) {
+            this._material = new SpriteMaterial()
+        }
+        return this._material
+    }
+
+    static type = SpriteDescriptor.type
+    
+    protected createActor(descriptor: SpriteDescriptor, args: UpdateArgs) {
+        const actor = new NodeActor(new Sprite())
+        return actor
+    }
+
+    useMaterial(material: string, args: UpdateArgs) {
+        const materialDescriptor = Asset.get(material)
+        if (materialDescriptor === null) return SpriteInterpreter.material
+
+        const interpreter = this.graphics.getInterpreter(materialDescriptor)
+        const actor = interpreter.getActor<MaterialActor>(materialDescriptor, args)
+        return actor.object instanceof SpriteMaterial ? actor.object : SpriteInterpreter.material
+    }
+
+    getMaterial(descriptor: SpriteDescriptor, args: UpdateArgs) {
+        return this.useMaterial(descriptor.material, args)
+    }
+
+    update(descriptor: SpriteDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<NodeActor<Sprite>>(descriptor, args)
+        actor.object.material = this.getMaterial(descriptor, args)
+    }
+}
+NodeInterpreter.register(SpriteInterpreter)
+
+export { SpriteInterpreter }

package/src/interpreter/TextInterpreter.ts

@@ -0,0 +1,76 @@
+import { BufferGeometry, Mesh } from "three";
+import { Font } from 'three/examples/jsm/loaders/FontLoader.js'
+import { Asset, UpdateArgs } from "@vyr/engine";
+import { TextDescriptor } from "../descriptor";
+import { NodeInterpreter } from "./NodeInterpreter";
+import { NodeActor } from "../actor";
+import { geometry, TextUtils, material } from "../utils";
+
+class TextInterpreter extends NodeInterpreter {
+    static type = TextDescriptor.type
+    private _geometry = new BufferGeometry()
+    private _cacheKey = ''
+
+    protected createActor(descriptor: TextDescriptor, args: UpdateArgs) {
+        const actor = new NodeActor(new Mesh(this._geometry, material.defaultMaterial()))
+        return actor
+    }
+
+    private _fastHash(str: string): number {
+        let hash1 = 5381;  // djb2初始值
+        let hash2 = 0x811C9DC5; // FNV-1初始值
+
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash1 = (hash1 * 33) ^ char;
+            hash2 = (hash2 * 0x01000193) ^ char;
+        }
+
+        // 组合两个哈希值，大幅降低碰撞概率
+        return ((hash1 >>> 0) ^ (hash2 >>> 0)) >>> 0;
+    }
+
+    getCacheKey(descriptor: TextDescriptor) {
+        return `${this._fastHash(descriptor.text)}_${descriptor.size}_${descriptor.lineHeight}_${descriptor.maxWidth}_${descriptor.letterSpacing}`
+    }
+
+    setAttribute(descriptor: TextDescriptor, args: UpdateArgs) {
+        const font = Asset.get<Font>(descriptor.font)
+        if (font instanceof Font) {
+            const options = {
+                size: descriptor.size,
+                lineHeight: descriptor.lineHeight,
+                maxWidth: descriptor.maxWidth,
+                letterSpacing: descriptor.letterSpacing,
+            }
+            const source = TextUtils.createTextGeometry(descriptor.text, descriptor.maxWidth, font, options)
+            this._geometry.copy(source)
+            source.dispose()
+        } else {
+            const source = new BufferGeometry()
+            this._geometry.copy(source)
+            source.dispose()
+        }
+
+        if (descriptor.flattenUVsToPlane) geometry.flattenUVsToPlane(this._geometry)
+    }
+
+    update(descriptor: TextDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<NodeActor<Mesh>>(descriptor, args)
+        const cacheKey = this.getCacheKey(descriptor)
+        if (this._cacheKey !== cacheKey) {
+            this.setAttribute(descriptor, args)
+            this._cacheKey = cacheKey
+        }
+        actor.object.material = material.getMaterial(descriptor.material, this.graphics, args)
+    }
+
+    free(descriptor: TextDescriptor, args: UpdateArgs) {
+        this._geometry.dispose()
+        super.free(descriptor, args)
+    }
+}
+NodeInterpreter.register(TextInterpreter)
+
+export { TextInterpreter }

package/src/interpreter/TransformControllerInterpreter.ts

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

package/src/interpreter/animation/AnimationActionInterpreter.ts

@@ -0,0 +1,66 @@
+import { AnimationAction, AnimationMixer } from 'three'
+import { Descriptor, Interpreter, UpdateArgs } from "@vyr/engine"
+import { AnimationActionDescriptor, ModelDescriptor } from "../../descriptor"
+import { ModelInterpreter } from '../ModelInterpreter'
+import { ServiceSchedulerInterpreter } from '../ServiceSchedulerInterpreter'
+
+class AnimationActionInterpreter extends Interpreter {
+    static type = AnimationActionDescriptor.type
+    animationAction: AnimationAction | null = null
+
+    freeAction(mixer: AnimationMixer) {
+        if (this.animationAction) {
+            this.animationAction.stop()
+            const clip = this.animationAction.getClip()
+            mixer.uncacheAction(clip, this.animationAction.getRoot())
+            this.animationAction = null
+        }
+    }
+
+    setProperty(action: AnimationAction, descriptor: AnimationActionDescriptor, args: UpdateArgs) {
+        action.enabled = descriptor.enabled
+        action.timeScale = descriptor.timeScale
+        action.weight = descriptor.weight
+        action.zeroSlopeAtStart = descriptor.zeroSlopeAtStart
+        action.zeroSlopeAtEnd = descriptor.zeroSlopeAtEnd
+        action.startAt(descriptor.startTime)
+        action.setDuration(descriptor.duration)
+        action.setLoop(descriptor.loop as any, descriptor.repetitions)
+        descriptor.play ? action.play() : action.stop()
+    }
+
+    update(descriptor: AnimationActionDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const scheduler = this.graphics.getInterpreter<ServiceSchedulerInterpreter>(this.graphics.scheduler)
+        this.freeAction(scheduler.mixer)
+
+        const parentDescriptor = ModelDescriptor.get<ModelDescriptor>(this.unit.parent)
+        const parentInterpreter = this.graphics.getInterpreter<ModelInterpreter>(parentDescriptor)
+
+        if (parentInterpreter instanceof ModelInterpreter) {
+            const model = parentInterpreter.wrapper.children[0]
+            if (model === undefined) return
+            for (const clip of model.animations) {
+                if (clip.name === descriptor.clip) {
+                    this.animationAction = scheduler.mixer.clipAction(clip, model)
+                    this.animationAction.clampWhenFinished = true
+                    this.setProperty(this.animationAction, descriptor, args)
+                }
+            }
+        }
+    }
+
+    mount(descriptor: AnimationActionDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
+        this.getActor(descriptor, args)
+    }
+
+    unmount(descriptor: AnimationActionDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const scheduler = this.graphics.getInterpreter<ServiceSchedulerInterpreter>(this.graphics.scheduler)
+        this.freeAction(scheduler.mixer)
+        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+    }
+}
+Interpreter.register(AnimationActionInterpreter)
+
+export { AnimationActionInterpreter }

package/src/interpreter/geometry/BoxGeometryInterpreter.ts

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

package/src/interpreter/geometry/BufferGeometryInterpreter.ts

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

package/src/interpreter/geometry/CircleGeometryInterpreter.ts

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

package/src/interpreter/geometry/CylinderGeometryInterpreter.ts

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

package/src/interpreter/geometry/ExtrudeGeometryInterpreter.ts

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

package/src/interpreter/geometry/PlaneGeometryInterpreter.ts

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

package/src/interpreter/geometry/RingGeometryInterpreter.ts

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