@vyr/three 0.0.1

package/src/descriptor/material/MeshStandardMaterialDescriptor.ts

@@ -0,0 +1,99 @@
+import { DefaultStyleColor, DeserializationObject, Euler, Vector2 } from "@vyr/engine"
+import { MaterialDescriptor, MaterialNormalMapType } from "./MaterialDescriptor"
+
+class MeshStandardMaterialDescriptor extends MaterialDescriptor {
+    static type = 'MeshStandardMaterial'
+    /**漫反射颜色 */
+    color: DefaultStyleColor
+    /**漫反射贴图 */
+    map: string
+    /**透明度贴图 */
+    alphaMap: string
+    /**环境贴图 */
+    envMap: string
+    /**环境贴图强度 */
+    envMapIntensity: number
+    /**光照贴图 */
+    lightMap: string
+    /**烘焙光的强度 */
+    lightMapIntensity: number
+
+    /**环境贴图的旋转（以弧度为单位）。默认值为 (0,0,0)。 */
+    envMapRotation: Euler
+    /**该纹理的红色通道用作环境遮挡贴图。默认值为null。aoMap需要第二组UV。 */
+    aoMap: string
+    /**环境遮挡效果的强度。默认值为1。零是不遮挡效果。 */
+    aoMapIntensity: number
+    /**凹凸贴图 */
+    bumpMap: string
+    /**凹凸贴图会对材质产生多大影响 */
+    bumpScale: number
+    /**位移贴图会影响网格顶点的位置，与仅影响材质的光照和阴影的其他贴图不同，移位的顶点可以投射阴影，阻挡其他对象， 以及充当真实的几何体。位移纹理是指：网格的所有顶点被映射为图像中每个像素的值（白色是最高的），并且被重定位。 */
+    displacementMap: string
+    /**位移贴图对网格的影响程度（黑色是无位移，白色是最大位移）。如果没有设置位移贴图，则不会应用此值。默认值为1。 */
+    displacementScale: number
+    /**位移贴图在网格顶点上的偏移量。如果没有设置位移贴图，则不会应用此值。默认值为0。 */
+    displacementBias: number
+    /**材质的放射（光）颜色 */
+    emissive: string
+    /**放射（发光）贴图 */
+    emissiveMap: string
+    /**放射光强度 */
+    emissiveIntensity: number
+    /**材质的金属度贴图 */
+    metalnessMap: string
+    /**材质与金属的相似度.木材或石材，使用0.0，金属使用1.0 */
+    metalness: number
+    /**材质的法线贴图 */
+    normalMap: string
+    /**法线贴图的类型。*/
+    normalMapType: number
+    /**法线贴图对材质的影响程度 */
+    normalScale: Vector2
+    /**材质的粗糙程度 */
+    roughness: number
+    /**材质的粗糙度贴图 */
+    roughnessMap: string
+    /**定义材质是否使用平面着色进行渲染。默认值为false。 */
+    flatShading: boolean
+    /**材质是否受雾影响。默认为true。 */
+    fog: boolean
+    /**将几何体渲染为线框。默认值为false */
+    wireframe: boolean
+
+    constructor(descriptor: Partial<DeserializationObject<MeshStandardMaterialDescriptor>> = {}) {
+        super(descriptor)
+        this.color = descriptor.color ? new DefaultStyleColor(descriptor.color) : new DefaultStyleColor({ value: '#ffffff' })
+        this.map = descriptor.map ?? ''
+        this.alphaMap = descriptor.alphaMap ?? ''
+        this.envMapIntensity = descriptor.envMapIntensity ?? 1
+        this.lightMapIntensity = descriptor.lightMapIntensity ?? 1
+        this.envMap = descriptor.envMap ?? ''
+        this.lightMap = descriptor.lightMap ?? ''
+
+        this.envMapRotation = Euler.create(descriptor.envMapRotation)
+        this.aoMap = descriptor.aoMap ?? ''
+        this.aoMapIntensity = descriptor.aoMapIntensity ?? 1
+        this.bumpMap = descriptor.bumpMap ?? ''
+        this.bumpScale = descriptor.bumpScale ?? 1
+        this.displacementMap = descriptor.displacementMap ?? ''
+        this.displacementScale = descriptor.displacementScale ?? 1
+        this.displacementBias = descriptor.displacementBias ?? 0
+        this.emissive = descriptor.emissive ?? '#000000'
+        this.emissiveMap = descriptor.emissiveMap ?? ''
+        this.emissiveIntensity = descriptor.emissiveIntensity ?? 1
+        this.metalness = descriptor.metalness ?? 0
+        this.metalnessMap = descriptor.metalnessMap ?? ''
+        this.normalMap = descriptor.normalMap ?? ''
+        this.normalMapType = descriptor.normalMapType ?? MaterialNormalMapType.TangentSpaceNormalMap
+        this.normalScale = descriptor.normalScale ? Vector2.create(descriptor.normalScale) : Vector2.create(1, 1)
+        this.roughness = descriptor.roughness ?? 1
+        this.roughnessMap = descriptor.roughnessMap ?? ''
+        this.flatShading = descriptor.flatShading ?? false
+        this.fog = descriptor.fog ?? true
+        this.wireframe = descriptor.wireframe ?? false
+    }
+}
+MaterialDescriptor.register(MeshStandardMaterialDescriptor)
+
+export { MeshStandardMaterialDescriptor }

package/src/descriptor/material/PointsMaterialDescriptor.ts

@@ -0,0 +1,31 @@
+import { DefaultStyleColor, DeserializationObject } from "@vyr/engine"
+import { MaterialDescriptor } from "./MaterialDescriptor"
+
+class PointsMaterialDescriptor extends MaterialDescriptor {
+    static type = 'PointsMaterial'
+    /**漫反射颜色 */
+    color: DefaultStyleColor
+    /**漫反射贴图 */
+    map: string
+    /**透明度贴图 */
+    alphaMap: string
+    /**点的的大小 */
+    size: number
+    /**点的大小是否会被相机深度衰减 */
+    sizeAttenuation: boolean
+    /**材质是否受雾影响。默认为true。 */
+    fog: boolean
+
+    constructor(descriptor: Partial<DeserializationObject<PointsMaterialDescriptor>> = {}) {
+        super(descriptor)
+        this.color = descriptor.color ? new DefaultStyleColor(descriptor.color) : new DefaultStyleColor({ value: '#ffffff' })
+        this.map = descriptor.map ?? ''
+        this.alphaMap = descriptor.alphaMap ?? ''
+        this.size = descriptor.size ?? 1
+        this.sizeAttenuation = descriptor.sizeAttenuation ?? true
+        this.fog = descriptor.fog ?? true
+    }
+}
+MaterialDescriptor.register(PointsMaterialDescriptor)
+
+export { PointsMaterialDescriptor }

package/src/descriptor/material/ShaderMaterialDescriptor.ts

@@ -0,0 +1,35 @@
+import { DeserializationObject } from "@vyr/engine"
+import { MaterialDescriptor } from "./MaterialDescriptor"
+
+interface ShaderMaterialAttribute {
+    uniforms: { [k: string]: any },
+    fragmentShader: string
+    vertexShader: string
+}
+
+class ShaderMaterialDescriptor extends MaterialDescriptor {
+    static type = 'ShaderMaterial'
+    /**材质是否受到光照的影响 */
+    lights: boolean
+    /**定义材质是否使用平面着色进行渲染 */
+    flatShading: boolean
+    /**材质是否受雾影响。默认为true。 */
+    fog: boolean
+    /**将几何体渲染为线框。默认值为false */
+    wireframe: boolean
+    /**着色器材质所需的资产 */
+    shader: string
+
+    constructor(descriptor: Partial<DeserializationObject<ShaderMaterialDescriptor>> = {}) {
+        super(descriptor)
+        this.lights = descriptor.lights ?? false
+        this.vertexColors = descriptor.vertexColors ?? false
+        this.flatShading = descriptor.flatShading ?? false
+        this.fog = descriptor.fog ?? true
+        this.wireframe = descriptor.wireframe ?? false
+        this.shader = descriptor.shader ?? ''
+    }
+}
+MaterialDescriptor.register(ShaderMaterialDescriptor)
+
+export { ShaderMaterialAttribute, ShaderMaterialDescriptor }

package/src/descriptor/material/ShadowMaterialDescriptor.ts

@@ -0,0 +1,19 @@
+import { DefaultStyleColor, DeserializationObject } from "@vyr/engine"
+import { MaterialDescriptor } from "./MaterialDescriptor"
+
+class ShadowMaterialDescriptor extends MaterialDescriptor {
+    static type = 'ShadowMaterial'
+    /**漫反射颜色 */
+    color: DefaultStyleColor
+    /**材质是否受雾影响。默认为true。 */
+    fog: boolean
+
+    constructor(descriptor: Partial<DeserializationObject<ShadowMaterialDescriptor>> = {}) {
+        super(descriptor)
+        this.color = descriptor.color ? new DefaultStyleColor(descriptor.color) : new DefaultStyleColor({ value: '#ffffff' })
+        this.fog = descriptor.fog ?? true
+    }
+}
+MaterialDescriptor.register(ShadowMaterialDescriptor)
+
+export { ShadowMaterialDescriptor }

package/src/descriptor/material/SpriteMaterialDescriptor.ts

@@ -0,0 +1,31 @@
+import { DefaultStyleColor, DeserializationObject } from "@vyr/engine"
+import { MaterialDescriptor } from "./MaterialDescriptor"
+
+class SpriteMaterialDescriptor extends MaterialDescriptor {
+    static type = 'SpriteMaterial'
+    /**漫反射颜色 */
+    color: DefaultStyleColor
+    /**漫反射贴图 */
+    map: string
+    /**透明度贴图 */
+    alphaMap: string
+    /**sprite的转动 */
+    rotation: number
+    /**精灵的大小是否会被相机深度衰减 */
+    sizeAttenuation: boolean
+    /**材质是否受雾影响。默认为true。 */
+    fog: boolean
+
+    constructor(descriptor: Partial<DeserializationObject<SpriteMaterialDescriptor>> = {}) {
+        super(descriptor)
+        this.color = descriptor.color ? new DefaultStyleColor(descriptor.color) : new DefaultStyleColor({ value: '#ffffff' })
+        this.map = descriptor.map ?? ''
+        this.alphaMap = descriptor.alphaMap ?? ''
+        this.rotation = descriptor.rotation ?? 0
+        this.sizeAttenuation = descriptor.sizeAttenuation ?? true
+        this.fog = descriptor.fog ?? true
+    }
+}
+MaterialDescriptor.register(SpriteMaterialDescriptor)
+
+export { SpriteMaterialDescriptor }

package/src/descriptor/texture/TextureDescriptor.ts

@@ -0,0 +1,110 @@
+import * as THREE from 'three'
+import { Descriptor, DeserializationObject, Vector2 } from '@vyr/engine'
+
+enum TextureMapping {
+    UVMapping = THREE.UVMapping,
+    CubeReflectionMapping = THREE.CubeReflectionMapping,
+    CubeRefractionMapping = THREE.CubeRefractionMapping,
+    EquirectangularReflectionMapping = THREE.EquirectangularReflectionMapping,
+    EquirectangularRefractionMapping = THREE.EquirectangularRefractionMapping,
+    CubeUVReflectionMapping = THREE.CubeUVReflectionMapping,
+}
+enum TextureWrap {
+    RepeatWrapping = THREE.RepeatWrapping,
+    ClampToEdgeWrapping = THREE.ClampToEdgeWrapping,
+    MirroredRepeatWrapping = THREE.MirroredRepeatWrapping,
+}
+enum TextureFType {
+    UnsignedByteType = THREE.UnsignedByteType,
+    ByteType = THREE.ByteType,
+    ShortType = THREE.ShortType,
+    UnsignedShortType = THREE.UnsignedShortType,
+    IntType = THREE.IntType,
+    UnsignedIntType = THREE.UnsignedIntType,
+    FloatType = THREE.FloatType,
+    HalfFloatType = THREE.HalfFloatType,
+    UnsignedShort4444Type = THREE.UnsignedShort4444Type,
+    UnsignedShort5551Type = THREE.UnsignedShort5551Type,
+    UnsignedInt248Type = THREE.UnsignedInt248Type,
+    UnsignedInt5999Type = THREE.UnsignedInt5999Type,
+}
+enum TextureFormat {
+    AlphaFormat = THREE.AlphaFormat,
+    RedFormat = THREE.RedFormat,
+    RedIntegerFormat = THREE.RedIntegerFormat,
+    RGFormat = THREE.RGFormat,
+    RGIntegerFormat = THREE.RGIntegerFormat,
+    RGBFormat = THREE.RGBFormat,
+    RGBAFormat = THREE.RGBAFormat,
+    RGBAIntegerFormat = THREE.RGBAIntegerFormat,
+    DepthFormat = THREE.DepthFormat,
+    DepthStencilFormat = THREE.DepthStencilFormat,
+}
+const TextureColorSpace = {
+    NoColorSpace: THREE.NoColorSpace,
+    SRGBColorSpace: THREE.SRGBColorSpace,
+    LinearSRGBColorSpace: THREE.LinearSRGBColorSpace,
+} as const
+
+class TextureDescriptor extends Descriptor {
+    static type = 'Texture'
+    url: string
+
+    /**图像将如何应用到物体（对象）上。
+     * 
+     *  - 1 
+     */
+    mapping: number
+    /**这个值定义了纹理贴图在水平方向上将如何包裹
+     * 
+     *  - 1 
+     */
+    wrapS: number
+    /**这个值定义了纹理贴图在垂直方向上将如何包裹
+     * 
+     *  - 1 
+     */
+    wrapT: number
+    /**定义shader（着色器）将如何读取的2D纹理或者texels（纹理元素）的元素
+     * 
+     */
+    format: number
+    /**这个值必须与format相对应 */
+    ftype: number
+    offset: Vector2
+    repeat: Vector2
+    center: Vector2
+    rotation: number
+    generateMipmaps: boolean
+    premultiplyAlpha: boolean
+    flipY: boolean
+    colorSpace: string
+
+    constructor(descriptor: Partial<DeserializationObject<TextureDescriptor>> = {}) {
+        super(descriptor)
+        this.url = descriptor.url ?? ''
+        this.mapping = descriptor.mapping ?? TextureMapping.UVMapping
+        this.wrapS = descriptor.wrapS ?? TextureWrap.ClampToEdgeWrapping
+        this.wrapT = descriptor.wrapT ?? TextureWrap.ClampToEdgeWrapping
+        this.format = descriptor.format ?? TextureFormat.RGBAFormat
+        this.ftype = descriptor.ftype ?? TextureFType.UnsignedByteType
+        this.offset = Vector2.create(descriptor.offset)
+        this.repeat = descriptor.repeat ? Vector2.create(descriptor.repeat) : Vector2.create(1, 1)
+        this.center = Vector2.create(descriptor.center)
+        this.rotation = descriptor.rotation ?? 0
+        this.generateMipmaps = descriptor.generateMipmaps ?? true
+        this.premultiplyAlpha = descriptor.premultiplyAlpha ?? false
+        this.flipY = descriptor.flipY ?? true
+        this.colorSpace = descriptor.colorSpace ?? TextureColorSpace.SRGBColorSpace
+    }
+}
+Descriptor.register(TextureDescriptor)
+
+export {
+    TextureMapping,
+    TextureWrap,
+    TextureFType,
+    TextureFormat,
+    TextureColorSpace,
+    TextureDescriptor,
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export * as THREE from 'three'
+export * from './locale'
+export * from './utils'
+export * from './asset'
+export * from './descriptor'
+export * from './actor'
+export * from './interpreter'
+export * from './preset'
+export * from './controls'

package/src/interpreter/ComposerServiceInterpreter.ts

@@ -0,0 +1,25 @@
+// import { UpdateArgs } from '@vyr/engine'
+// import { ComposerServiceDescriptor } from '../descriptor/ComposerServiceDescriptor'
+// import { SceneServiceInterpreter } from './SceneServiceInterpreter'
+// import { ComposerServiceActor } from '../actor'
+
+// class ComposerServiceInterpreter extends SceneServiceInterpreter {
+//     static type = ComposerServiceDescriptor.type
+
+//     protected createActor(descriptor: ComposerServiceDescriptor, args: UpdateArgs) {
+//         const actor = new ComposerServiceActor(descriptor)
+//         return actor
+//     }
+
+//     protected setSize(actor: ComposerServiceActor) {
+//         const rect = super.setSize(actor)
+//         const descriptor = ComposerServiceDescriptor.get<ComposerServiceDescriptor>(this.unit.uuid)
+//         const composer = actor.getEffectComposer(descriptor)
+//         composer.setSize(rect.width, rect.height)
+//         return rect
+//     }
+// }
+
+// SceneServiceInterpreter.register(ComposerServiceInterpreter)
+
+// export { ComposerServiceInterpreter }

package/src/interpreter/GeoMapInterpreter.ts

@@ -0,0 +1,253 @@
+import { Material, Mesh, Object3D, Vector2 as _V2, BufferGeometry } from "three";
+import { Asset, AsyncTask, Category, Data, DatasetDescriptor, Descriptor, Generate, Graphics, Interpreter, JsonAsset, observer, PrefabeDescriptor, PrefabInstanceDescriptor, Queue, RoutineDescriptor, RoutineNode, Unit, UpdateArgs, Vector2 } from "@vyr/engine";
+import { ExtrudeGeometryDescriptor, GeoMapDescriptor, GeometryDescriptor, HTMLConvertDescriptor, PlaneGeometryDescriptor, TubeGeometryDescriptor } from '../descriptor'
+import { NodeInterpreter, PickupNode } from "./NodeInterpreter";
+import { material, diaposeObject3D, collectionPickupResult } from "../utils";
+import { NodeActor } from "../actor";
+import { executePreset, routinePreset } from "../preset";
+
+interface GeoFeature<T extends BufferGeometry = BufferGeometry> {
+    url: string
+    descriptor: GeometryDescriptor
+    interpreter: Interpreter
+    dataset: string
+    mesh: Mesh<T>
+}
+
+type GeometryFactory<T extends GeometryDescriptor = GeometryDescriptor> = (url: string, dataset: string, feature: JsonAsset, offset: Vector2) => T
+
+const tubeFactory: GeometryFactory = (url: string, dataset: string, feature: JsonAsset, offset: Vector2) => {
+    const descriptor = new TubeGeometryDescriptor({ name: feature.properties.adcode, track: dataset, offset, radius: 0.05, tubularSegments: 1000 })
+    Asset.set(url, descriptor)
+
+    let datasetDescriptor = Asset.get<DatasetDescriptor>(dataset)
+    if (datasetDescriptor === null) {
+        datasetDescriptor = new DatasetDescriptor({ name: feature.properties.adcode })
+        let data
+        if (feature.geometry.type === 'MultiPolygon') {
+            data = feature.geometry.coordinates[0][0]
+        } else if (feature.geometry.type === 'Polygon') {
+            data = feature.geometry.coordinates[0]
+        } else {
+            data = []
+        }
+        datasetDescriptor.setData(data)
+        Asset.set(dataset, datasetDescriptor)
+    }
+
+    return descriptor
+}
+
+const shadowFactory: GeometryFactory = (url: string, dataset: string, feature: JsonAsset, offset: Vector2) => {
+    const descriptor = new PlaneGeometryDescriptor({ name: feature.properties.adcode, width: 100, height: 100 })
+    Asset.set(url, descriptor)
+
+    return descriptor
+}
+
+const extrudeFactory: GeometryFactory = (url: string, dataset: string, feature: JsonAsset, offset: Vector2) => {
+    const descriptor = new ExtrudeGeometryDescriptor({ name: feature.properties.adcode, shapes: dataset, offset, flattenUVsToPlane: true })
+    Asset.set(url, descriptor)
+
+    let datasetDescriptor = Asset.get<DatasetDescriptor>(dataset)
+    if (datasetDescriptor === null) {
+        datasetDescriptor = new DatasetDescriptor({ name: feature.properties.adcode })
+        let data
+        if (feature.geometry.type === 'MultiPolygon') {
+            data = feature.geometry.coordinates
+        } else {
+            data = []
+        }
+        datasetDescriptor.setData(data)
+        Asset.set(dataset, datasetDescriptor)
+    }
+
+    return descriptor
+}
+
+class GeoMapInterpreter extends NodeInterpreter {
+    static type = GeoMapDescriptor.type
+    private _task: AsyncTask | null = null
+    readonly wrapper = new Object3D()
+    readonly features: GeoFeature[] = []
+    readonly labels: HTMLConvertDescriptor[] = []
+    readonly routines: RoutineDescriptor[] = []
+
+    protected createActor(descriptor: Descriptor, args: UpdateArgs) {
+        const actor = new NodeActor(new Object3D())
+        actor.object.add(this.wrapper)
+        return actor
+    }
+
+    private createLabel(descriptor: GeoMapDescriptor, prefab: PrefabeDescriptor, featureData: Data, feature: JsonAsset, offset: Vector2) {
+        const point = feature.properties.centroid ?? feature.properties.center
+        if (!point) return null
+
+        const label = new HTMLConvertDescriptor({})
+        label.position.x = point[0] + offset.x
+        label.position.y = point[1] + offset.y
+        label.position.z = 2
+        label.scale.x = 0.05
+        label.scale.y = 0.05
+        label.scale.z = 0.05
+
+        const clone = PrefabInstanceDescriptor.fromPrefab(descriptor.label, prefab)
+        label.add(clone)
+
+        const datasetUrl = Asset.createVirtualUrl(`GeoMap/dataset/label/${feature.properties.adcode}${Category.datasetSuffix}`)
+        const dataset = new DatasetDescriptor()
+        dataset.setData(featureData)
+        Asset.set(datasetUrl, dataset)
+
+        const inputs = {
+            [routinePreset.GeoMap.drilldown.nodes.drilldown]: executePreset.GeoMap.drilldown.createExecuteInput({
+                dataset,
+                geoMap: descriptor,
+            })
+        }
+        clone.traverse(sub => {
+            sub.dataset = datasetUrl
+            sub.interactions.push({
+                uuid: Generate.uuid(),
+                type: "click",
+                url: routinePreset.GeoMap.drilldown.url,
+                inputs,
+            })
+        })
+
+        return label
+    }
+    private _createGeoData(fullJson: JsonAsset) {
+        const data: Data = {}
+        for (const feature of fullJson.features) {
+            data[feature.properties.adcode] = feature.properties
+        }
+        return data
+    }
+    buildLabel(descriptor: GeoMapDescriptor, fullJson: JsonAsset, offset: Vector2, args: UpdateArgs) {
+        const prefab = Asset.get<PrefabeDescriptor>(descriptor.label)
+        if (prefab === null) return
+        const dataset = Asset.get<DatasetDescriptor>(descriptor.dataset)
+        const data = dataset === null ? this._createGeoData(fullJson) : dataset.getData<Data>()
+
+        for (const feature of fullJson.features) {
+            const featureData = data[feature.properties.adcode]
+            const label = this.createLabel(descriptor, prefab, featureData, feature, offset)
+            if (label === null) continue
+            this.labels.push(label)
+            observer.trigger('add', { puid: this.unit.uuid, self: label.uuid })
+        }
+    }
+
+    buildFeature(feature: JsonAsset, materials: Material | Material[], offset: Vector2, factory: GeometryFactory, args: UpdateArgs, flag: string) {
+        const geometryUrl = Asset.createVirtualUrl(`GeoMap/geometry/${flag}/${feature.properties.adcode}${Category.geometrySuffix}`)
+        const datasetUrl = Asset.createVirtualUrl(`GeoMap/dataset/${flag}/${feature.properties.adcode}${Category.datasetSuffix}`)
+
+        let geometry = Asset.get<GeometryDescriptor>(geometryUrl)
+        if (geometry === null) {
+            geometry = factory(geometryUrl, datasetUrl, feature, offset)
+        }
+        const interpreter = Graphics.createInterpreter(geometry, this.graphics)
+        //@ts-ignore
+        interpreter.unit = new Unit(geometry.uuid, '', this.unit.queue)
+        interpreter.update(geometry, args)
+        const actor = interpreter.getActor(geometry, args)
+
+        const mesh = new Mesh(actor.object, materials)
+
+        this.wrapper.add(mesh)
+
+        const item: GeoFeature = { url: geometryUrl, descriptor: geometry, interpreter, dataset: datasetUrl, mesh }
+
+        return item
+    }
+
+    buildBorder(fullJson: JsonAsset, materials: Material | Material[], offset: Vector2, features: GeoFeature[], args: UpdateArgs) {
+        for (const feature of fullJson.features) {
+            const item = this.buildFeature(feature, materials, offset, tubeFactory, args, 'border')
+            item.mesh.position.z = 1.22
+            features.push(item)
+        }
+    }
+
+    buildShadow(feature: JsonAsset, materials: Material | Material[], offset: Vector2, args: UpdateArgs) {
+        const region = this.buildFeature(feature, materials, offset, shadowFactory, args, 'shadow')
+        this.features.push(region)
+        return region
+    }
+
+    buildRegion(feature: JsonAsset, materials: Material | Material[], offset: Vector2, args: UpdateArgs) {
+        const region = this.buildFeature(feature, materials, offset, extrudeFactory, args, 'region')
+        this.features.push(region)
+        return region
+    }
+
+    async build(descriptor: GeoMapDescriptor, args: UpdateArgs) {
+        const geojson = Asset.get<JsonAsset>(descriptor.geojsonRegion)
+        if (Array.isArray(geojson.features) === false || geojson.features.length === 0) return
+
+        const regionMaterials = material.getMaterial(descriptor.material, this.graphics, args)
+        const borderMaterial = descriptor.borderMaterial ? material.getMaterial(descriptor.borderMaterial, this.graphics, args) : regionMaterials
+
+        const regionJson = geojson.features[0]
+        const offset = new Vector2(-regionJson.properties.centroid[0], -regionJson.properties.centroid[1])
+        const region = this.buildRegion(regionJson, regionMaterials, offset, args)
+        region.mesh.castShadow = descriptor.castShadow
+
+        if (descriptor.shadowMaterial) {
+            const shadowMaterials = material.getMaterial(descriptor.shadowMaterial, this.graphics, args)
+            const shadow = this.buildShadow(regionJson, shadowMaterials, offset, args)
+            shadow.mesh.receiveShadow = descriptor.castShadow
+        }
+
+        const fullJson = Asset.get<JsonAsset>(descriptor.geojsonBorder)
+        if (fullJson !== null && Array.isArray(fullJson.features)) {
+            if (descriptor.label) this.buildLabel(descriptor, fullJson, offset, args)
+            this.buildBorder(fullJson, borderMaterial, offset, this.features, args)
+        }
+    }
+
+    async clear() {
+        this.wrapper.clear()
+        for (const feature of this.features) {
+            diaposeObject3D(feature.mesh)
+            Asset.unload(feature.url)
+            Asset.unload(feature.dataset)
+        }
+        this.features.length = 0
+        for (const label of this.labels) {
+            observer.trigger('remove', { puid: this.unit.uuid, self: label.uuid })
+            Asset.unload(label.dataset)
+        }
+        this.labels.length = 0
+        if (this._task !== null) this._task.cancel()
+    }
+
+    update(descriptor: GeoMapDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+
+        this.wrapper.layers.set(descriptor.layer)
+        this.wrapper.visible = descriptor.visible
+
+        this.clear()
+        if (descriptor.geojsonRegion) this.build(descriptor, args)
+    }
+
+    unmount(descriptor: GeoMapDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        this.clear()
+        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+    }
+
+    free(descriptor: GeoMapDescriptor, args: UpdateArgs) {
+        this.clear()
+        super.free(descriptor, args)
+    }
+
+    pickup(descriptor: GeoMapDescriptor, args: UpdateArgs, result: PickupNode[]) {
+        if (descriptor.visible === false) return
+        collectionPickupResult(this.wrapper, true, descriptor, result)
+    }
+}
+NodeInterpreter.register(GeoMapInterpreter)
+
+export { GeoMapInterpreter }

package/src/interpreter/HTMLConvertInterpreter.ts

@@ -0,0 +1,31 @@
+import { Object3D } from 'three'
+import { Descriptor, Interpreter, PickupObject, UpdateArgs } from "@vyr/engine";
+import { HTMLConvertDescriptor } from "../descriptor";
+import { NodeInterpreter } from "./NodeInterpreter";
+import { HTMLConvertActor } from '../actor';
+
+class HTMLConvertInterpreter extends NodeInterpreter {
+    static type = HTMLConvertDescriptor.type
+
+    protected createActor(descriptor: Descriptor, args: UpdateArgs) {
+        const actor = new HTMLConvertActor(new Object3D())
+        return actor
+    }
+
+    unmount(descriptor: HTMLConvertDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<HTMLConvertActor>(descriptor, args)
+        actor.clear()
+        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+    }
+
+    free(descriptor: HTMLConvertDescriptor, args: UpdateArgs) {
+        const actor = this.getActor<HTMLConvertActor>(descriptor, args)
+        actor.clear()
+        super.free(descriptor, args)
+    }
+
+    pickup(descriptor: HTMLConvertDescriptor, args: UpdateArgs, result: PickupObject[]) { }
+}
+NodeInterpreter.register(HTMLConvertInterpreter)
+
+export { HTMLConvertInterpreter }