@vyr/three 0.0.1

package/src/interpreter/material/MeshStandardMaterialInterpreter.ts

@@ -0,0 +1,58 @@
+import { MeshStandardMaterial } from "three";
+import { UpdateArgs } from "@vyr/engine";
+import { MaterialInterpreter } from "./MaterialInterpreter";
+import { MeshStandardMaterialDescriptor } from "../../descriptor";
+import { MaterialActor } from "../../actor";
+import { texture } from "../../utils";
+
+class MeshStandardMaterialInterpreter extends MaterialInterpreter {
+    static type = MeshStandardMaterialDescriptor.type
+
+    protected createActor(descriptor: MeshStandardMaterialDescriptor, args: UpdateArgs) {
+        const actor = new MaterialActor(new MeshStandardMaterial())
+        return actor
+    }
+
+    setProperty(material: MeshStandardMaterial, descriptor: MeshStandardMaterialDescriptor) {
+        super.setProperty(material, descriptor)
+
+        material.color.setStyle(descriptor.color.value)
+        material.opacity = descriptor.color.opacity
+        material.lightMapIntensity = descriptor.lightMapIntensity
+        material.envMapIntensity = descriptor.envMapIntensity
+        material.envMapRotation.set(descriptor.envMapRotation.x, descriptor.envMapRotation.y, descriptor.envMapRotation.z)
+        material.bumpScale = descriptor.bumpScale
+        material.aoMapIntensity = descriptor.aoMapIntensity
+        material.displacementScale = descriptor.displacementScale
+        material.displacementBias = descriptor.displacementBias
+        material.emissive.setStyle(descriptor.emissive)
+        material.emissiveIntensity = descriptor.emissiveIntensity
+        material.metalness = descriptor.metalness
+        //@ts-ignore
+        material.normalMapType = descriptor.normalMapType
+        material.normalScale.set(descriptor.normalScale.x, descriptor.normalScale.y)
+        material.roughness = descriptor.roughness
+        material.flatShading = descriptor.flatShading
+        material.fog = descriptor.fog
+        material.wireframe = descriptor.wireframe
+    }
+
+    update(descriptor: MeshStandardMaterialDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<MaterialActor<MeshStandardMaterial>>(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, 'lightMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'aoMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'bumpMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'displacementMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'emissiveMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'metalnessMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'normalMap', descriptor, this.graphics, args)
+        texture.setMap(actor.object, 'roughnessMap', descriptor, this.graphics, args)
+    }
+}
+MaterialInterpreter.register(MeshStandardMaterialInterpreter)
+
+export { MeshStandardMaterialInterpreter }

package/src/interpreter/material/PointsMaterialInterpreter.ts

@@ -0,0 +1,36 @@
+import { PointsMaterial } from "three";
+import { UpdateArgs } from "@vyr/engine";
+import { MaterialInterpreter } from './MaterialInterpreter'
+import { PointsMaterialDescriptor } from "../../descriptor";
+import { MaterialActor } from "../../actor";
+import { texture } from "../../utils";
+
+class PointsMaterialInterpreter extends MaterialInterpreter {
+    static type = PointsMaterialDescriptor.type
+
+    protected createActor(descriptor: PointsMaterialDescriptor, args: UpdateArgs) {
+        const actor = new MaterialActor(new PointsMaterial())
+        return actor
+    }
+
+    setProperty(material: PointsMaterial, descriptor: PointsMaterialDescriptor) {
+        super.setProperty(material, descriptor)
+
+        material.color.setStyle(descriptor.color.value)
+        material.opacity = descriptor.color.opacity
+        material.size = descriptor.size
+        material.sizeAttenuation = descriptor.sizeAttenuation
+        material.fog = descriptor.fog
+    }
+
+    update(descriptor: PointsMaterialDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<MaterialActor<PointsMaterial>>(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)
+    }
+}
+MaterialInterpreter.register(PointsMaterialInterpreter)
+
+export { PointsMaterialInterpreter }

package/src/interpreter/material/ShaderMaterialInterpreter.ts

@@ -0,0 +1,51 @@
+import { ShaderMaterial } from "three";
+import { Asset, Scriptable, UpdateArgs } from "@vyr/engine";
+import { MaterialInterpreter } from './MaterialInterpreter'
+import { MaterialActor } from "../../actor";
+import { ShaderMaterialAttribute, ShaderMaterialDescriptor } from "../../descriptor";
+
+class ShaderMaterialInterpreter extends MaterialInterpreter {
+    static type = ShaderMaterialDescriptor.type
+    static defaultVertexShader = 'void main() { gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );}'
+    static defaultFragmentShader = 'void main() { gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );}'
+
+    protected createActor(descriptor: ShaderMaterialDescriptor, args: UpdateArgs) {
+        const actor = new MaterialActor(new ShaderMaterial())
+        return actor
+    }
+
+    setProperty(material: ShaderMaterial, descriptor: ShaderMaterialDescriptor) {
+        super.setProperty(material, descriptor)
+        material.lights = descriptor.lights
+        //@ts-ignore
+        material.flatShading = descriptor.flatShading
+        material.fog = descriptor.fog
+        material.wireframe = descriptor.wireframe
+    }
+
+    setShaderAsset(material: ShaderMaterial, descriptor: ShaderMaterialDescriptor, args: UpdateArgs) {
+        material.uniforms = {}
+        material.vertexShader = ShaderMaterialInterpreter.defaultVertexShader
+        material.fragmentShader = ShaderMaterialInterpreter.defaultFragmentShader
+        material.uniformsNeedUpdate = true
+
+        if (descriptor.shader) {
+            const shaderAsset = Asset.get<Scriptable>(descriptor.shader)
+            if (shaderAsset === null) return
+            const attribute: ShaderMaterialAttribute = shaderAsset.execute(descriptor, this.graphics, args)
+            material.uniforms = attribute.uniforms
+            material.fragmentShader = attribute.fragmentShader
+            material.vertexShader = attribute.vertexShader
+        }
+    }
+
+    update(descriptor: ShaderMaterialDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<MaterialActor<ShaderMaterial>>(descriptor, args)
+        this.setProperty(actor.object, descriptor)
+        this.setShaderAsset(actor.object, descriptor, args)
+    }
+}
+MaterialInterpreter.register(ShaderMaterialInterpreter)
+
+export { ShaderMaterialInterpreter }

package/src/interpreter/material/ShadowMaterialInterpreter.ts

@@ -0,0 +1,31 @@
+import { ShadowMaterial } from "three";
+import { UpdateArgs } from "@vyr/engine";
+import { MaterialInterpreter } from './MaterialInterpreter'
+import { ShadowMaterialDescriptor } from "../../descriptor";
+import { MaterialActor } from "../../actor";
+
+class ShadowMaterialInterpreter extends MaterialInterpreter {
+    static type = ShadowMaterialDescriptor.type
+
+    protected createActor(descriptor: ShadowMaterialDescriptor, args: UpdateArgs) {
+        const actor = new MaterialActor(new ShadowMaterial())
+        return actor
+    }
+
+    setProperty(material: ShadowMaterial, descriptor: ShadowMaterialDescriptor) {
+        super.setProperty(material, descriptor)
+
+        material.color.setStyle(descriptor.color.value)
+        material.opacity = descriptor.color.opacity
+        material.fog = descriptor.fog
+    }
+
+    update(descriptor: ShadowMaterialDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<MaterialActor<ShadowMaterial>>(descriptor, args)
+        this.setProperty(actor.object, descriptor)
+    }
+}
+MaterialInterpreter.register(ShadowMaterialInterpreter)
+
+export { ShadowMaterialInterpreter }

package/src/interpreter/material/SpriteMaterialInterpreter.ts

@@ -0,0 +1,36 @@
+import { SpriteMaterial } from "three";
+import { UpdateArgs } from "@vyr/engine";
+import { MaterialInterpreter } from './MaterialInterpreter'
+import { SpriteMaterialDescriptor } from "../../descriptor";
+import { MaterialActor } from "../../actor";
+import { texture } from "../../utils";
+
+class SpriteMaterialInterpreter extends MaterialInterpreter {
+    static type = SpriteMaterialDescriptor.type
+
+    protected createActor(descriptor: SpriteMaterialDescriptor, args: UpdateArgs) {
+        const actor = new MaterialActor(new SpriteMaterial())
+        return actor
+    }
+
+    setProperty(material: SpriteMaterial, descriptor: SpriteMaterialDescriptor) {
+        super.setProperty(material, descriptor)
+
+        material.color.setStyle(descriptor.color.value)
+        material.opacity = descriptor.color.opacity
+        material.rotation = descriptor.rotation
+        material.sizeAttenuation = descriptor.sizeAttenuation
+        material.fog = descriptor.fog
+    }
+
+    update(descriptor: SpriteMaterialDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        const actor = this.getActor<MaterialActor<SpriteMaterial>>(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)
+    }
+}
+MaterialInterpreter.register(SpriteMaterialInterpreter)
+
+export { SpriteMaterialInterpreter }

package/src/interpreter/texture/TextureInterpreter.ts

@@ -0,0 +1,59 @@
+import { Texture } from "three";
+import { Asset, Interpreter, UpdateArgs } from "@vyr/engine";
+import { TextureDescriptor } from '../../descriptor'
+import { TextureActor } from "../../actor";
+
+class TextureInterpreter extends Interpreter {
+    static type = TextureDescriptor.type
+
+    protected createActor(descriptor: TextureDescriptor, args: UpdateArgs) {
+        const actor = new TextureActor(new Texture())
+        return actor
+    }
+
+    setProperty(actor: TextureActor, descriptor: TextureDescriptor) {
+        //@ts-ignore
+        actor.object.mapping = descriptor.mapping
+        //@ts-ignore
+        actor.object.wrapS = descriptor.wrapS
+        //@ts-ignore
+        actor.object.wrapT = descriptor.wrapT
+        //@ts-ignore
+        actor.object.format = descriptor.format
+        //@ts-ignore
+        actor.object.type = descriptor.ftype
+        actor.object.colorSpace = descriptor.colorSpace
+
+        actor.object.offset.set(descriptor.offset.x, descriptor.offset.y)
+        actor.object.repeat.set(descriptor.repeat.x, descriptor.repeat.y)
+        actor.object.center.set(descriptor.center.x, descriptor.center.y)
+        actor.object.rotation = descriptor.rotation
+        actor.object.generateMipmaps = descriptor.generateMipmaps
+        actor.object.premultiplyAlpha = descriptor.premultiplyAlpha
+        actor.object.flipY = descriptor.flipY
+    }
+
+    setImage(actor: TextureActor, descriptor: TextureDescriptor) {
+        if (descriptor.url) {
+            const image = Asset.get<HTMLImageElement>(descriptor.url)
+            if (image instanceof HTMLImageElement) actor.object.image = image
+        }
+    }
+
+    update(descriptor: TextureDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+        let actor = this.getActor<TextureActor>(descriptor, args)
+        this.setProperty(actor, descriptor)
+        this.setImage(actor, descriptor)
+        if (actor.object.image) actor.object.needsUpdate = true
+    }
+
+    free(descriptor: TextureDescriptor, args: UpdateArgs) {
+        const actor = this.getActor<TextureActor>(descriptor, args)
+        actor.object.dispose()
+        super.free(descriptor, args)
+    }
+}
+Interpreter.register(TextureInterpreter)
+
+export { TextureInterpreter }

package/src/locale/Language.ts

@@ -0,0 +1,10 @@
+import { Locale } from "@vyr/locale";
+import { zhCnLanguageProvider, ZhCNLanguageProvider } from "./LanguageProvider";
+
+Locale.register(zhCnLanguageProvider)
+
+const language = Locale.getLanguage<ZhCNLanguageProvider>(zhCnLanguageProvider.name)
+
+export {
+    language
+}

package/src/locale/LanguageProvider.ts

@@ -0,0 +1,16 @@
+import { LanguageProvider } from '@vyr/locale'
+
+interface ZhCNLanguageProvider extends LanguageProvider {
+    '/virtual:/preset/GeoMap/drilldown.ts': string
+}
+
+const zhCnLanguageProvider: ZhCNLanguageProvider = {
+    id: 'zh_CN',
+    name: '@vyr/three',
+    '/virtual:/preset/GeoMap/drilldown.ts': '地图下钻',
+}
+
+export {
+    ZhCNLanguageProvider,
+    zhCnLanguageProvider,
+}

package/src/locale/index.ts

@@ -0,0 +1,2 @@
+export * from './LanguageProvider'
+export * from './Language'

package/src/preset/execute/GeoMap/drilldown.ts

@@ -0,0 +1,61 @@
+import { Asset, Descriptor, Graphics, RoutineNode, Scriptable, UpdateArgs } from "@vyr/engine"
+import { language } from '../../../locale'
+import { GeoMapDescriptor } from "../../../descriptor"
+
+const scriptable = Asset.createVirtualUrl('preset/GeoMap/drilldown.ts')
+class RoutineScriptable extends Scriptable {
+    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
+        //@ts-ignore
+        const { dataset, geoMap } = args.input.user
+
+        const data = dataset.value.getData()
+        if (data.level === "district") return
+
+        if (geoMap.value instanceof GeoMapDescriptor) {
+            const clips = geoMap.value.geojsonRegion.split('/')
+            clips.pop()
+
+            const root = clips.join('/')
+            geoMap.value.geojsonRegion = `${root}/${data.adcode}.json`
+            geoMap.value.geojsonBorder = `${root}/${data.adcode}_full.json`
+
+            Asset.load(geoMap.value.geojsonRegion)
+            Asset.load(geoMap.value.geojsonBorder)
+
+            await Asset.readly()
+            Asset.graph.update(graphics.url)
+
+            geoMap.value.setNeedsUpdate()
+        }
+    }
+}
+Asset.provider(scriptable, async () => ({ default: RoutineScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+        dataset: { value: args.dataset ?? '' },
+        geoMap: { value: args.geoMap ?? '' },
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: RoutineNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        routine: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/src/preset/execute/GeoMap/index.ts

@@ -0,0 +1 @@
+export * as drilldown from './drilldown'

package/src/preset/execute/index.ts

@@ -0,0 +1 @@
+export * as GeoMap from './GeoMap'

package/src/preset/index.ts

@@ -0,0 +1,7 @@
+import * as executePreset from './execute'
+import * as routinePreset from './routine'
+
+export {
+    executePreset,
+    routinePreset
+}

package/src/preset/routine/GeoMap/drilldown.ts

@@ -0,0 +1,26 @@
+import { Asset, RoutineDescriptor } from "@vyr/engine"
+import { GeoMap } from "../../execute"
+
+const url = Asset.createVirtualUrl('preset/GeoMap/drilldown.routine.json')
+const nodes = {
+    drilldown: 'drilldown',
+}
+let _currentRoutine: RoutineDescriptor | null = null
+const routineProvider = async () => {
+    if (_currentRoutine === null) {
+        _currentRoutine = new RoutineDescriptor()
+        const drilldownNode = GeoMap.drilldown.createExecuteNode({ id: nodes.drilldown })
+        _currentRoutine.addNode([drilldownNode])
+        _currentRoutine.roots.push(drilldownNode.id)
+    }
+    return _currentRoutine
+}
+
+Asset.provider(url, routineProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/preset/routine/GeoMap/index.ts

@@ -0,0 +1 @@
+export * as drilldown from './drilldown'

package/src/preset/routine/index.ts

@@ -0,0 +1 @@
+export * as GeoMap from './GeoMap'

package/src/utils/dispose/index.ts

@@ -0,0 +1,23 @@
+import { Material, Mesh, Object3D, Skeleton, Texture } from 'three'
+
+function disposeMaterial(material: Material) {
+    material.dispose();
+
+    const keys = Object.keys(material) as Array<keyof Material>
+    for (const key of keys) {
+        const value = material[key]
+        if (value && value instanceof Texture) value.dispose()
+    }
+}
+
+const diaposeObject3D = (obj: Object3D) => {
+    obj.traverse(sub => {
+        if (sub instanceof Mesh) {
+            Array.isArray(sub.material) ? sub.material.forEach(disposeMaterial) : disposeMaterial(sub.material)
+            sub.geometry.dispose()
+        }
+        if (sub instanceof Skeleton) sub.boneTexture?.dispose()
+    })
+}
+
+export { diaposeObject3D }

package/src/utils/geometry/index.ts

@@ -0,0 +1,82 @@
+import { Box3, BufferGeometry, Vector2, Vector3 } from 'three'
+import { Asset, Graphics, JsonAsset, UpdateArgs, Vector2 as V2 } from '@vyr/engine'
+import { ExtrudeGeometryDescriptor } from '../../descriptor'
+import { GeometryActor } from '../../actor'
+
+const getPointsOfshapeData = (data: JsonAsset, offset: V2) => {
+    const points: Vector2[] = []
+
+    for (let i = 0; i < data.length; i++) {
+        points.push(new Vector2(data[i][0] + offset.x, data[i][1] + offset.y))
+    }
+
+    return points
+}
+
+const getPointsOfLineData = (data: JsonAsset, offset: V2) => {
+    const points: Vector3[] = []
+
+    for (let i = 0; i < data.length; i++) {
+        points.push(new Vector3(data[i][0] + offset.x, data[i][1] + offset.y, 0))
+    }
+
+    return points
+}
+
+const getExtrudeOptions = (descriptor: ExtrudeGeometryDescriptor) => {
+    return {
+        curveSegments: descriptor.curveSegments,
+        steps: descriptor.steps,
+        depth: descriptor.depth,
+        bevelEnabled: descriptor.bevelEnabled,
+        bevelThickness: descriptor.bevelThickness,
+        bevelSize: descriptor.bevelSize,
+        bevelOffset: descriptor.bevelOffset,
+        bevelSegments: descriptor.bevelSegments,
+    }
+}
+
+const flattenUVsToPlane = (geometry: BufferGeometry) => {
+    geometry.computeBoundingBox()
+    const box3 = geometry.boundingBox as Box3
+    const bboxSize = box3.getSize(new Vector3());
+    const bboxMin = box3.min
+
+    const position = geometry.getAttribute('position')
+    const uv = geometry.getAttribute('uv')
+    for (let i = 0; i < position.count; i++) {
+        const x = position.getX(i)
+        const y = position.getY(i)
+
+        const u = (x - bboxMin.x) / bboxSize.x;
+        const v = (y - bboxMin.y) / bboxSize.y;
+        uv.setX(i, u)
+        uv.setY(i, v)
+    }
+}
+
+let _geometry: BufferGeometry | null = null
+const defaultGeometry = () => {
+    if (_geometry === null) {
+        _geometry = new BufferGeometry()
+    }
+    return _geometry
+}
+
+const getGeometry = (geometry: string, graphics: Graphics, args: UpdateArgs) => {
+    const geometryDescriptor = Asset.get(geometry)
+    if (geometryDescriptor === null) return defaultGeometry()
+
+    const interpreter = graphics.getInterpreter(geometryDescriptor)
+    const actor = interpreter.getActor<GeometryActor<BufferGeometry>>(geometryDescriptor, args)
+    return actor.object instanceof BufferGeometry ? actor.object : defaultGeometry()
+}
+
+export {
+    getPointsOfshapeData,
+    getPointsOfLineData,
+    getExtrudeOptions,
+    flattenUVsToPlane,
+    defaultGeometry,
+    getGeometry,
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from './random'
+export * from './dispose'
+export * from './pickup'
+export * from './text'
+export * as geometry from './geometry'
+export * as material from './material'
+export * as texture from './texture'

package/src/utils/material/index.ts

@@ -0,0 +1,53 @@
+import { Material, MeshBasicMaterial } from 'three'
+import { Asset, AssetPropertyCollection, Category, Graphics, Port, UpdateArgs } from '@vyr/engine'
+import { MaterialActor } from '../../actor'
+
+let _material: Material | null = null
+const defaultMaterial = () => {
+    if (_material === null) {
+        _material = new MeshBasicMaterial()
+    }
+    return _material
+}
+
+const useMaterial = (material: string, graphics: Graphics, args: UpdateArgs) => {
+    const materialDescriptor = Asset.get(material)
+    if (materialDescriptor === null) return defaultMaterial()
+
+    const interpreter = graphics.getInterpreter(materialDescriptor)
+    const actor = interpreter.getActor<MaterialActor<Material>>(materialDescriptor, args)
+    return actor.object instanceof Material ? actor.object : defaultMaterial()
+}
+
+const getMaterial = (materialValue: string | AssetPropertyCollection, graphics: Graphics, args: UpdateArgs) => {
+    if (typeof materialValue === 'string') {
+        return useMaterial(materialValue, graphics, args)
+    } else {
+        const materials: Material[] = []
+        for (const material of materialValue) {
+            const actor = useMaterial(material.url, graphics, args)
+            materials.push(actor)
+        }
+        return materials
+    }
+}
+
+const pickMaterial = (source: string | AssetPropertyCollection, port: Port) => {
+    if (Array.isArray(source)) {
+        for (let i = 0; i < source.length; i++) {
+            const material = source[i]
+            if (material.url) {
+                port.edges.push({ key: `material[${i}].url`, category: Category.material, asset: material.url })
+            }
+        }
+    } else {
+        if (source) port.edges.push({ key: 'material', category: Category.material, asset: source })
+    }
+}
+
+export {
+    defaultMaterial,
+    useMaterial,
+    getMaterial,
+    pickMaterial,
+}

package/src/utils/pickup/index.ts

@@ -0,0 +1,16 @@
+import { Object3D } from "three";
+import { Descriptor } from "@vyr/engine";
+import { PickupNode, SceneServiceInterpreter } from "../../interpreter";
+
+const collectionPickupResult = (target: Object3D, recursive: boolean, descriptor: Descriptor, result: PickupNode[]) => {
+    const intersection = SceneServiceInterpreter.ray.intersectObject(target, recursive)
+    if (intersection.length === 0) return
+    let minDistance = Infinity
+    for (const item of intersection) if (item.distance < minDistance) minDistance = item.distance
+    const pickupObject: PickupNode = { uuid: descriptor.uuid, generatedBy: descriptor.generatedBy, intersection, minDistance }
+    result.push(pickupObject)
+}
+
+export {
+    collectionPickupResult
+}

package/src/utils/random/index.ts

@@ -0,0 +1,7 @@
+const randomRange = (min: number, max: number) => {
+    return Math.random() * (max - min) + min;
+}
+
+export {
+    randomRange
+}