├── rustfmt.toml
├── demo
    ├── .gitignore
    ├── src
    │   ├── types.js
    │   ├── index.js
    │   ├── worker.js
    │   └── OffscreenTileLayer.js
    ├── README.md
    ├── package.json
    ├── index.html
    ├── vite.config.js
    └── package-lock.json
├── .gitignore
├── tests
    ├── pbf
    │   └── osm_4_8_5.pbf
    ├── render_test.rs
    └── utils.rs
├── rust-toolchain
├── .cargo
    └── config.toml
├── .github
    ├── actions
    │   ├── install-graphics-driver
    │   │   └── action.yml
    │   ├── post-build-env
    │   │   └── action.yml
    │   └── prepare-build-env
    │   │   └── action.yml
    ├── dependabot.yml
    └── workflows
    │   └── ci.yml
├── webdriver.json
├── pkg
    └── package.json
├── LICENSE
├── src
    ├── ressource
    │   ├── tile
    │   │   ├── line.rs
    │   │   ├── point.rs
    │   │   ├── fill.rs
    │   │   └── mod.rs
    │   ├── material
    │   │   ├── fill.rs
    │   │   ├── line.rs
    │   │   ├── point.rs
    │   │   ├── shader
    │   │   │   └── common.wgsl
    │   │   └── mod.rs
    │   ├── view.rs
    │   └── mod.rs
    ├── tessellation
    │   ├── shader
    │   │   └── line.wgsl
    │   └── mod.rs
    ├── renderer.rs
    └── lib.rs
├── Cargo.toml
├── README.md
└── examples
    └── window.rs


/rustfmt.toml:
--------------------------------------------------------------------------------
1 | tab_spaces = 2


--------------------------------------------------------------------------------
/demo/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | dist/
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /.vscode
2 | /target
3 | **/*.rs.bk
4 | bin/
5 | pkg/
6 | wasm-pack.log
7 | 


--------------------------------------------------------------------------------
/tests/pbf/osm_4_8_5.pbf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codeart1st/wgpu-layers/HEAD/tests/pbf/osm_4_8_5.pbf


--------------------------------------------------------------------------------
/rust-toolchain:
--------------------------------------------------------------------------------
1 | [toolchain]
2 | channel = "nightly-2025-01-03"
3 | components = ["clippy", "rustfmt", "rust-src"]
4 | targets = ["wasm32-unknown-unknown"]
5 | profile = "minimal"


--------------------------------------------------------------------------------
/demo/src/types.js:
--------------------------------------------------------------------------------
1 | export const READY = 'ready'
2 | export const STARTED = 'started'
3 | export const CANVAS = 'canvas'
4 | export const SHARED_ARRAY_BUFFER = 'sab'
5 | export const PBF_DATA = 'pbf-data'


--------------------------------------------------------------------------------
/demo/README.md:
--------------------------------------------------------------------------------
1 | # How to use
2 | 
3 | ```bash
4 | # because of https://github.com/npm/cli/issues/6033
5 | # and https://github.com/rustwasm/wasm-pack/issues/1206
6 | npm install --install-links=false
7 | npm run dev
8 | ```


--------------------------------------------------------------------------------
/.cargo/config.toml:
--------------------------------------------------------------------------------
1 | [target.wasm32-unknown-unknown]
2 | rustflags = ["-C", "target-feature=+simd128,+atomics,+bulk-memory,+mutable-globals", "--cfg=web_sys_unstable_apis"]
3 | 
4 | [unstable]
5 | build-std = ["panic_abort", "std"]


--------------------------------------------------------------------------------
/.github/actions/install-graphics-driver/action.yml:
--------------------------------------------------------------------------------
 1 | name: Install graphics driver
 2 | description: Ensures that all necessary Mesa libraries are installed
 3 | 
 4 | runs:
 5 |   using: "composite"
 6 |   steps:
 7 |     - name: Install mesa dependencies
 8 |       shell: bash
 9 |       run: sudo apt-get update -qq && sudo apt-get install -y libegl1-mesa mesa-vulkan-drivers xvfb
10 | 


--------------------------------------------------------------------------------
/webdriver.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "moz:firefoxOptions": {
 3 |     "binary": "/tmp/firefox-nightly/firefox/firefox",
 4 |     "prefs": {
 5 |       "dom.webgpu.enabled": true
 6 |     },
 7 |     "args": []
 8 |   },
 9 |   "goog:chromeOptions": {
10 |     "args": [
11 |       "--enable-unsafe-webgpu",
12 |       "--enable-features=Vulkan,VulkanFromANGLE",
13 |       "--use-angle=swiftshader"
14 |     ]
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/demo/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "wgpu-layers-demo",
 3 |   "version": "0.1.0",
 4 |   "author": "Paul Lange <paul.lange@data-experts.de>",
 5 |   "license": "MIT",
 6 |   "type": "module",
 7 |   "scripts": {
 8 |     "dev": "vite",
 9 |     "build": "vite build",
10 |     "preview": "vite preview"
11 |   },
12 |   "dependencies": {
13 |     "ol": "10.6.1",
14 |     "wgpu-layers": "file:../pkg"
15 |   },
16 |   "devDependencies": {
17 |     "vite": "7.1.11"
18 |   }
19 | }
20 | 


--------------------------------------------------------------------------------
/demo/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang='en'>
 3 |   <head>
 4 |     <meta charset='utf-8'>
 5 |     <title>wgpu-layers</title>
 6 |     <style type='text/css'>
 7 |       body {
 8 |         font-family: sans-serif;
 9 |         margin: 0;
10 |       }
11 | 
12 |       #map {
13 |         width: 100vw;
14 |         height: 100vh;
15 |       }
16 |     </style>
17 |   </head>
18 |   <body>
19 |     <div id='map'></div>
20 |     <script type="module" src="/src/index.js"></script>
21 |   </body>
22 | </html>
23 | 


--------------------------------------------------------------------------------
/pkg/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "wgpu-layers",
 3 |   "type": "module",
 4 |   "collaborators": [
 5 |     "Paul Lange <paul.lange@data-experts.de>"
 6 |   ],
 7 |   "description": "WebGPU mapping renderer for OpenLayers",
 8 |   "version": "0.1.0",
 9 |   "license": "MIT",
10 |   "repository": {
11 |     "type": "git",
12 |     "url": "https://github.com/codeart1st/wgpu-layers"
13 |   },
14 |   "files": [
15 |     "wgpu_layers_bg.wasm",
16 |     "wgpu_layers.js",
17 |     "wgpu_layers.d.ts"
18 |   ],
19 |   "main": "wgpu_layers.js",
20 |   "types": "wgpu_layers.d.ts",
21 |   "sideEffects": [
22 |     "./snippets/*"
23 |   ]
24 | }


--------------------------------------------------------------------------------
/demo/vite.config.js:
--------------------------------------------------------------------------------
 1 | import { defineConfig, searchForWorkspaceRoot } from 'vite'
 2 | 
 3 | export default defineConfig({
 4 |   server: {
 5 |     headers: {
 6 |       'Cross-Origin-Opener-Policy': 'same-origin',
 7 |       'Cross-Origin-Embedder-Policy': 'require-corp'
 8 |     },
 9 |     proxy: {
10 |       '/tegola': {
11 |         target: 'https://tegola-osm-demo.go-spatial.org',
12 |         changeOrigin: true,
13 |         rewrite: path => path.replace(/^\/tegola/, ''),
14 |       },
15 |     },
16 |     fs: {
17 |       allow: [
18 |         searchForWorkspaceRoot(process.cwd()),
19 |         '../pkg'
20 |       ]
21 |     },
22 |     port: 8080
23 |   }
24 | })


--------------------------------------------------------------------------------
/.github/actions/post-build-env/action.yml:
--------------------------------------------------------------------------------
 1 | name: Post build environment
 2 | description: Clean up build environment actions
 3 | 
 4 | inputs:
 5 |   cargo-cache-primary-key:
 6 |     description: Primary key of cargo cache restore action
 7 |     required: true
 8 |   cargo-cache-hit:
 9 |     description: A boolean value to indicate an exact match was found for the cargo cache restore action
10 |     required: true
11 | 
12 | runs:
13 |   using: "composite"
14 |   steps:
15 |     - name: Cache cargo output (save)
16 |       if: inputs.cargo-cache-hit != 'true' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop')
17 |       uses: actions/cache/save@v4.2.4
18 |       with:
19 |         path: |
20 |           ~/.cargo/bin/
21 |           ~/.cargo/.crates.toml
22 |           ~/.cargo/.crates2.json
23 |           ~/.cargo/.package-cache
24 |           ~/.cargo/registry/
25 |           ~/.cargo/git/db/
26 |           target/
27 |         key: ${{ inputs.cargo-cache-primary-key }}
28 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2022-now Paul Lange <paul.lange@data-experts.de>
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining
 4 | a copy of this software and associated documentation files (the
 5 | "Software"), to deal in the Software without restriction, including
 6 | without limitation the rights to use, copy, modify, merge, publish,
 7 | distribute, sublicense, and/or sell copies of the Software, and to
 8 | permit persons to whom the Software is furnished to do so, subject to
 9 | the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/src/ressource/tile/line.rs:
--------------------------------------------------------------------------------
 1 | use mvt_reader::feature::Feature;
 2 | 
 3 | use crate::ressource::{BindGroupScope, RessourceManager, material::MaterialType};
 4 | 
 5 | use super::{Bucket, BucketType, Tile, TileUniform};
 6 | 
 7 | impl<F> Bucket<F, { BucketType::Line }> for Tile {
 8 |   fn new(ressource_manager: &RessourceManager, extent: [f32; 4]) -> Self {
 9 |     let tile_uniform = TileUniform::default();
10 |     let tile_uniform_buffer =
11 |       ressource_manager.create_buffer_init(&wgpu::util::BufferInitDescriptor {
12 |         label: None,
13 |         contents: bytemuck::cast_slice(&[tile_uniform]),
14 |         usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
15 |       });
16 |     let bind_group =
17 |       ressource_manager.create_bind_group(&BindGroupScope::Model, &[wgpu::BindGroupEntry {
18 |         binding: 0,
19 |         resource: tile_uniform_buffer.as_entire_binding(),
20 |       }]);
21 | 
22 |     Self {
23 |       material: ressource_manager.get_material(MaterialType::Line),
24 |       bind_group,
25 |       tile_uniform_buffer,
26 |       vertex_wgpu_buffer: None,
27 |       vertex_buffer: Vec::with_capacity(0),
28 |       index_wgpu_buffer: None,
29 |       index_buffer: Vec::with_capacity(0),
30 |       instance_wgpu_buffer: None,
31 |       extent,
32 |       bucket_type: BucketType::Line,
33 |     }
34 |   }
35 | 
36 |   fn add_features(&mut self, _: &mut Vec<Feature>, _: &RessourceManager) {}
37 | }
38 | 


--------------------------------------------------------------------------------
/demo/src/index.js:
--------------------------------------------------------------------------------
 1 | import 'ol/ol.css'
 2 | 
 3 | import { Map, View } from 'ol'
 4 | import { Tile } from 'ol/layer'
 5 | import { createXYZ } from 'ol/tilegrid'
 6 | import { TileDebug, VectorTile } from 'ol/source'
 7 | 
 8 | import { OffscreenTileLayer } from './OffscreenTileLayer'
 9 | 
10 | function start() {
11 |   const offscreenTileLayer = new OffscreenTileLayer()
12 |   const tileGrid = createXYZ({ maxZoom: 22 })
13 |   const vectorTileSource = new VectorTile({
14 |     tileGrid,
15 |     zDirection: 0, // same as TileDebug
16 |     tileLoadFunction: async (tile, src) => {
17 |       const { tileCoord, extent } = tile
18 |       if (tileCoord[0] != 4) {
19 |         tile.setFeatures([]) // finish tile loading
20 |         return
21 |       }
22 |       const response = await fetch(src)
23 |       const pbf = await response.arrayBuffer()
24 |       await offscreenTileLayer.pushPbfTileData(pbf, tileCoord, extent)
25 |       tile.setFeatures([]) // finish tile loading
26 |     },
27 |     url: 'https://tegola-osm-demo.go-spatial.org/v1/maps/osm/{z}/{x}/{y}'
28 |   })
29 |   vectorTileSource.getTileGridForProjection = () => { // override for better debug purposes
30 |     return tileGrid
31 |   }
32 |   offscreenTileLayer.setSource(vectorTileSource)
33 |   new Map({
34 |     target: 'map',
35 |     layers: [
36 |       offscreenTileLayer,
37 |       new Tile({
38 |         source: new TileDebug({
39 |           tileGrid
40 |         })
41 |       })
42 |     ],
43 |     view: new View({
44 |       center: [1489199.332673, 6894017.412561],
45 |       zoom: 4
46 |     })
47 |   })
48 | }
49 | 
50 | start()


--------------------------------------------------------------------------------
/src/tessellation/shader/line.wgsl:
--------------------------------------------------------------------------------
 1 | struct OutputVertex {
 2 |   position: vec2<f32>,
 3 |   normal: vec2<f32>,
 4 | }
 5 | 
 6 | @group(0) @binding(0)
 7 | var<storage, read> vertices : array<vec2<f32>>;
 8 | 
 9 | @group(0) @binding(1)
10 | var<storage, read> indices : array<u32>;
11 | 
12 | @group(0) @binding(2)
13 | var<storage, read_write> line_vertices : array<OutputVertex>;
14 | 
15 | @group(0) @binding(3)
16 | var<storage, read_write> line_indices : array<u32>;
17 | 
18 | @compute @workgroup_size(256, 1)
19 | fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
20 |   if (global_id.x >= arrayLength(&indices)) {
21 |     return;
22 |   }
23 | 
24 |   let i1 = indices[global_id.x];
25 |   let i2 = indices[global_id.x + 1u];
26 | 
27 |   if (i1 == i2 || (global_id.x > 0u && indices[global_id.x - 1u] == i1)) { // separate linestring from the next one
28 |     return;
29 |   }
30 | 
31 |   let v1 = vertices[i1];
32 |   let v2 = vertices[i2];
33 | 
34 |   let dx = v2.x - v1.x;
35 |   let dy = v2.y - v1.y;
36 |   let n1 = normalize(vec2<f32>(-dy, dx));
37 |   let n2 = normalize(vec2<f32>(dy, -dx));
38 | 
39 |   let ii1 = global_id.x * 4u;
40 |   let ii2 = ii1 + 1u;
41 |   let ii3 = ii1 + 2u;
42 |   let ii4 = ii1 + 3u;
43 | 
44 |   line_vertices[ii1] = OutputVertex(v1, n1);
45 |   line_vertices[ii2] = OutputVertex(v1, n2);
46 |   line_vertices[ii3] = OutputVertex(v2, n1);
47 |   line_vertices[ii4] = OutputVertex(v2, n2);
48 | 
49 |   let offset = global_id.x * 6u;
50 |   line_indices[offset + 0u] = ii1;
51 |   line_indices[offset + 1u] = ii2;
52 |   line_indices[offset + 2u] = ii3;
53 |   line_indices[offset + 3u] = ii3;
54 |   line_indices[offset + 4u] = ii2;
55 |   line_indices[offset + 5u] = ii4;
56 | }


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "wgpu-layers"
 3 | version = "0.1.0"
 4 | description = "WebGPU mapping renderer for OpenLayers"
 5 | authors = ["Paul Lange <paul.lange@data-experts.de>"]
 6 | repository = "https://github.com/codeart1st/wgpu-layers"
 7 | license = "MIT"
 8 | edition = "2024"
 9 | 
10 | [lib]
11 | crate-type = ["cdylib", "rlib"]
12 | 
13 | [features]
14 | multithreaded = []
15 | 
16 | [dependencies]
17 | log = "0.4.28"
18 | wgpu = { version = "25.0.2", default-features = false, features = ["wgsl", "webgpu", "vulkan"]}
19 | rayon = "1.11.0"
20 | futures = "0.3.31"
21 | geo-types = "0.7.17"
22 | bytemuck = "1.23.2"
23 | bytemuck_derive = "1.10.1"
24 | mvt-reader = "2.1.0"
25 | earcutr = "0.5.0"
26 | glam = { version = "0.30.5", default-features = false, features = ["libm", "bytemuck"] }
27 | 
28 | [target.'cfg(target_arch = "wasm32")'.dependencies]
29 | wasm-bindgen = "0.2.99"
30 | wasm-bindgen-futures = "0.4.49"
31 | wasm-bindgen-rayon = "1.3.0" # alternative https://github.com/chemicstry/wasm_thread
32 | console_log = { version = "1.0.0", optional = true }
33 | console_error_panic_hook = { version = "0.1.7", optional = true }
34 | web-sys = { version = "0.3.76", features = [
35 |   "OffscreenCanvas",
36 |   "HtmlElement", # from here all features are for integrationtests
37 |   "CssStyleDeclaration",
38 |   "HtmlCanvasElement",
39 |   "FileReader",
40 |   "Blob"
41 | ]}
42 | 
43 | [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
44 | pollster = "0.4.0"
45 | env_logger = "0.11.6"
46 | winit = "0.30.12"
47 | 
48 | [dev-dependencies]
49 | wasm-bindgen-test = "0.3.49"
50 | pdqhash = "0.1.1"
51 | js-sys = "0.3.76"
52 | 
53 | [profile.release]
54 | opt-level = "s"
55 | lto = true
56 | 
57 | [package.metadata.wasm-pack.profile.release]
58 | wasm-opt = false # version in wasm-pack is to old for simd128


--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | 
 3 | updates:
 4 |   - package-ecosystem: cargo
 5 |     directory: /
 6 |     schedule:
 7 |       interval: daily
 8 |     target-branch: "develop"
 9 |     open-pull-requests-limit: 10
10 |     groups:
11 |       development-dependencies:
12 |         dependency-type: "development"
13 | 
14 |   - package-ecosystem: npm
15 |     directory: /demo
16 |     schedule:
17 |       interval: daily
18 |     target-branch: "develop"
19 |     open-pull-requests-limit: 10
20 |     groups:
21 |       development-dependencies:
22 |         dependency-type: "development"
23 |       production-dependencies:
24 |         dependency-type: "production"
25 | 
26 |   - package-ecosystem: github-actions
27 |     directory: /
28 |     schedule:
29 |       interval: daily
30 |     target-branch: "develop"
31 |     open-pull-requests-limit: 10
32 |     groups:
33 |       actions:
34 |         dependency-type: "production"
35 | 
36 |   - package-ecosystem: github-actions
37 |     directory: /.github/actions/install-graphics-driver
38 |     schedule:
39 |       interval: daily
40 |     target-branch: "develop"
41 |     open-pull-requests-limit: 10
42 |     groups:
43 |       actions:
44 |         dependency-type: "production"
45 | 
46 |   - package-ecosystem: github-actions
47 |     directory: /.github/actions/prepare-build-env
48 |     schedule:
49 |       interval: daily
50 |     target-branch: "develop"
51 |     open-pull-requests-limit: 10
52 |     groups:
53 |       actions:
54 |         dependency-type: "production"
55 | 
56 |   - package-ecosystem: github-actions
57 |     directory: /.github/actions/post-build-env
58 |     schedule:
59 |       interval: daily
60 |     target-branch: "develop"
61 |     open-pull-requests-limit: 10
62 |     groups:
63 |       actions:
64 |         dependency-type: "production"
65 | 


--------------------------------------------------------------------------------
/src/ressource/material/fill.rs:
--------------------------------------------------------------------------------
 1 | use crate::ressource::{BindGroupScope, RessourceManager};
 2 | 
 3 | use super::{CreatePipeline, Material, MaterialType, Style};
 4 | 
 5 | impl CreatePipeline<{ MaterialType::Fill }> for Material {
 6 |   fn new(ressource_manager: &RessourceManager, shader_module: &wgpu::ShaderModule) -> Self {
 7 |     let vertex_state = wgpu::VertexState {
 8 |       module: shader_module,
 9 |       entry_point: Some("vs_fill"),
10 |       buffers: &[wgpu::VertexBufferLayout {
11 |         array_stride: 8,
12 |         step_mode: wgpu::VertexStepMode::Vertex,
13 |         attributes: &wgpu::vertex_attr_array![0 => Float32x2],
14 |       }],
15 |       compilation_options: wgpu::PipelineCompilationOptions::default(),
16 |     };
17 |     let fragment_state = wgpu::FragmentState {
18 |       module: shader_module,
19 |       entry_point: Some("fs_fill"),
20 |       targets: &[Some(wgpu::ColorTargetState {
21 |         format: ressource_manager.texture_format,
22 |         blend: Some(wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING),
23 |         write_mask: wgpu::ColorWrites::default(),
24 |       })],
25 |       compilation_options: wgpu::PipelineCompilationOptions::default(),
26 |     };
27 |     let pipeline = ressource_manager.create_render_pipeline(vertex_state, fragment_state);
28 | 
29 |     let style = Style {
30 |       fill_color: [0.506, 0.694, 0.31, 1.0],
31 |       stroke_color: [0.0, 0.0, 0.0, 1.0],
32 |       stroke_width: 0.0,
33 |       _pad: [0, 0, 0],
34 |     };
35 |     let style_buffer = ressource_manager.create_buffer_init(&wgpu::util::BufferInitDescriptor {
36 |       label: None,
37 |       contents: bytemuck::cast_slice(&[style]),
38 |       usage: wgpu::BufferUsages::UNIFORM,
39 |     });
40 |     let bind_group =
41 |       ressource_manager.create_bind_group(&BindGroupScope::Material, &[wgpu::BindGroupEntry {
42 |         binding: 0,
43 |         resource: style_buffer.as_entire_binding(),
44 |       }]);
45 | 
46 |     Self {
47 |       pipeline,
48 |       bind_group,
49 |     }
50 |   }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/ressource/material/line.rs:
--------------------------------------------------------------------------------
 1 | use crate::ressource::{BindGroupScope, RessourceManager};
 2 | 
 3 | use super::{CreatePipeline, Material, MaterialType, Style};
 4 | 
 5 | impl CreatePipeline<{ MaterialType::Line }> for Material {
 6 |   fn new(ressource_manager: &RessourceManager, shader_module: &wgpu::ShaderModule) -> Self {
 7 |     let vertex_state = wgpu::VertexState {
 8 |       module: shader_module,
 9 |       entry_point: Some("vs_stroke"),
10 |       buffers: &[wgpu::VertexBufferLayout {
11 |         array_stride: 16,
12 |         step_mode: wgpu::VertexStepMode::Vertex,
13 |         attributes: &wgpu::vertex_attr_array![0 => Float32x2, 1 => Float32x2],
14 |       }],
15 |       compilation_options: wgpu::PipelineCompilationOptions::default(),
16 |     };
17 |     let fragment_state = wgpu::FragmentState {
18 |       module: shader_module,
19 |       entry_point: Some("fs_stroke"),
20 |       targets: &[Some(wgpu::ColorTargetState {
21 |         format: ressource_manager.texture_format,
22 |         blend: Some(wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING),
23 |         write_mask: wgpu::ColorWrites::default(),
24 |       })],
25 |       compilation_options: wgpu::PipelineCompilationOptions::default(),
26 |     };
27 |     let pipeline = ressource_manager.create_render_pipeline(vertex_state, fragment_state);
28 | 
29 |     let stroke_width = 2.5;
30 |     let style = Style {
31 |       fill_color: [0.0, 0.0, 0.0, 1.0],
32 |       stroke_color: [0.0, 0.0, 0.0, 1.0],
33 |       stroke_width: stroke_width * 0.5, // multiply by half because of double sided buffer
34 |       _pad: [0, 0, 0],
35 |     };
36 |     let style_buffer = ressource_manager.create_buffer_init(&wgpu::util::BufferInitDescriptor {
37 |       label: None,
38 |       contents: bytemuck::cast_slice(&[style]),
39 |       usage: wgpu::BufferUsages::UNIFORM,
40 |     });
41 |     let bind_group =
42 |       ressource_manager.create_bind_group(&BindGroupScope::Material, &[wgpu::BindGroupEntry {
43 |         binding: 0,
44 |         resource: style_buffer.as_entire_binding(),
45 |       }]);
46 | 
47 |     Self {
48 |       pipeline,
49 |       bind_group,
50 |     }
51 |   }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/ressource/material/point.rs:
--------------------------------------------------------------------------------
 1 | use crate::ressource::{BindGroupScope, RessourceManager};
 2 | 
 3 | use super::{CreatePipeline, Material, MaterialType, Style};
 4 | 
 5 | impl CreatePipeline<{ MaterialType::Point }> for Material {
 6 |   fn new(ressource_manager: &RessourceManager, shader_module: &wgpu::ShaderModule) -> Self {
 7 |     let vertex_state = wgpu::VertexState {
 8 |       module: shader_module,
 9 |       entry_point: Some("vs_point"),
10 |       buffers: &[
11 |         wgpu::VertexBufferLayout {
12 |           array_stride: 8,
13 |           step_mode: wgpu::VertexStepMode::Vertex,
14 |           attributes: &wgpu::vertex_attr_array![0 => Float32x2],
15 |         },
16 |         wgpu::VertexBufferLayout {
17 |           array_stride: 8,
18 |           step_mode: wgpu::VertexStepMode::Instance,
19 |           attributes: &wgpu::vertex_attr_array![1 => Float32x2],
20 |         },
21 |       ],
22 |       compilation_options: wgpu::PipelineCompilationOptions::default(),
23 |     };
24 |     let fragment_state = wgpu::FragmentState {
25 |       module: shader_module,
26 |       entry_point: Some("fs_fill"),
27 |       targets: &[Some(wgpu::ColorTargetState {
28 |         format: ressource_manager.texture_format,
29 |         blend: Some(wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING),
30 |         write_mask: wgpu::ColorWrites::default(),
31 |       })],
32 |       compilation_options: wgpu::PipelineCompilationOptions::default(),
33 |     };
34 |     let pipeline = ressource_manager.create_render_pipeline(vertex_state, fragment_state);
35 | 
36 |     let style = Style {
37 |       fill_color: [1.0, 0.0, 0.0, 1.0],
38 |       stroke_color: [0.0, 0.0, 0.0, 1.0],
39 |       stroke_width: 0.0,
40 |       _pad: [0, 0, 0],
41 |     };
42 |     let style_buffer = ressource_manager.create_buffer_init(&wgpu::util::BufferInitDescriptor {
43 |       label: None,
44 |       contents: bytemuck::cast_slice(&[style]),
45 |       usage: wgpu::BufferUsages::UNIFORM,
46 |     });
47 |     let bind_group =
48 |       ressource_manager.create_bind_group(&BindGroupScope::Material, &[wgpu::BindGroupEntry {
49 |         binding: 0,
50 |         resource: style_buffer.as_entire_binding(),
51 |       }]);
52 | 
53 |     Self {
54 |       pipeline,
55 |       bind_group,
56 |     }
57 |   }
58 | }
59 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Preview
 2 | 
 3 | ![image](https://user-images.githubusercontent.com/581407/205440021-d99e2a8e-b83f-4032-a237-2b8d0fca2c6d.png)
 4 | 
 5 | ---
 6 | <div align="center">
 7 |   <strong>WebGPU mapping renderer for OpenLayers</strong>
 8 | </div>
 9 | <div align="center">
10 |   Currently only a playground for rust, wgpu, openlayers web mapping combo
11 | </div>
12 | <br>
13 | <div align="center">
14 |   <a href="https://github.com/codeart1st/wgpu-layers/actions/workflows/ci.yml">
15 |     <img src="https://github.com/codeart1st/wgpu-layers/actions/workflows/ci.yml/badge.svg" alt="Build status"/>
16 |   </a>
17 |   <a href="https://github.com/codeart1st/wgpu-layers/blob/main/LICENSE">
18 |     <img src="https://img.shields.io/github/license/codeart1st/wgpu-layers" alt="MIT license"/>
19 |   </a>
20 | </div>
21 | 
22 | # Build the project
23 | 
24 | ```sh
25 | wasm-pack build --release --all-features --target web
26 | ```
27 | 
28 | # Next goals
29 | 
30 | - [x] Fill
31 |   - [x] Initial support
32 | - [ ] Line
33 |   - [x] Initial support
34 |   - [x] Anti aliasing
35 |   - [ ] Line joins
36 |   - [ ] Line caps
37 | - [ ] Points
38 |   - [x] Initial support
39 |   - [ ] Shapes
40 | - [ ] Move polygon triangulation to worker threads
41 | - [ ] Architecture overhaul
42 |   - [ ] Combine tiles in buckets with same material
43 |   - [ ] Split code in smaller chunks
44 | - [ ] CI
45 |   - [x] Initial
46 |   - [ ] Deployment
47 |   - [ ] Publishing
48 | - [ ] OpenLayers integration
49 |   - [ ] Smooth frame sync
50 | 
51 | # Run a native example
52 | 
53 | ```sh
54 | cargo run --example window --target `rustc -vV | sed -n 's|host: ||p'`
55 | ```
56 | 
57 | # Run tests
58 | 
59 | Native unit tests
60 | ```sh
61 | LIBGL_ALWAYS_SOFTWARE=true cargo test --target `rustc -vV | sed -n 's|host: ||p'` -- --nocapture
62 | ```
63 | 
64 | WASM Browser Integration tests
65 | ```sh
66 | wasm-pack test --chrome --release --features console_log,console_error_panic_hook --test '*'
67 | ```
68 | 
69 | # Useful environment variables
70 | 
71 | | Name                  | Example |
72 | | --------------------- | ------- |
73 | | WGPU_BACKEND          | gl      |
74 | | LIBGL_ALWAYS_SOFTWARE | true    |
75 | | WINIT_UNIX_BACKEND    | x11     |
76 | | VK_ICD_FILENAMES      | /usr/share/vulkan/icd.d/lvp_icd.x86_64.json |
77 | 


--------------------------------------------------------------------------------
/tests/render_test.rs:
--------------------------------------------------------------------------------
 1 | #![feature(thread_local)]
 2 | #![allow(clippy::await_holding_refcell_ref)]
 3 | #![cfg(target_arch = "wasm32")]
 4 | 
 5 | mod utils;
 6 | 
 7 | use wasm_bindgen_test::*;
 8 | 
 9 | use utils::*;
10 | 
11 | wasm_bindgen_test_configure!(run_in_browser);
12 | 
13 | #[wasm_bindgen_test]
14 | async fn osm_pbf() {
15 |   initialize();
16 | 
17 |   // arrange
18 |   let canvas_ref = CANVAS.borrow();
19 |   let canvas = canvas_ref.as_ref().unwrap();
20 |   wgpu_layers::wasm::start_with_canvas(canvas).await;
21 |   wgpu_layers::add_pbf_tile_data(
22 |     include_bytes!("pbf/osm_4_8_5.pbf").to_vec(),
23 |     vec![4, 8, 5],
24 |     vec![0.0, 5009377.085697312, 2_504_688.5, 7_514_065.5],
25 |   )
26 |   .await;
27 | 
28 |   // act
29 |   wgpu_layers::render(get_view_matrix(), vec![CANVAS_SIZE.0, CANVAS_SIZE.1]);
30 |   timeout(500).await; // wait for compute shader
31 |   wgpu_layers::render(get_view_matrix(), vec![CANVAS_SIZE.0, CANVAS_SIZE.1]);
32 |   timeout(1500).await; // wait to render
33 | 
34 |   // assert
35 |   let image_data = get_canvas_image_data(canvas).await;
36 |   let image = pdqhash::image::load_from_memory(&image_data[..]).unwrap();
37 |   let (hash, _) = pdqhash::generate_pdq_full_size(&image);
38 | 
39 |   assert_eq!(
40 |     [
41 |       155, 210, 99, 215, 34, 140, 167, 36, 126, 218, 111, 44, 241, 6, 10, 205, 9, 179, 75, 237,
42 |       159, 35, 148, 131, 139, 45, 212, 131, 162, 190, 87, 48
43 |     ],
44 |     hash
45 |   );
46 | }
47 | 
48 | #[wasm_bindgen_test]
49 | async fn empty() {
50 |   initialize();
51 | 
52 |   // arrange
53 |   let canvas_ref = CANVAS.borrow();
54 |   let canvas = canvas_ref.as_ref().unwrap();
55 |   wgpu_layers::wasm::start_with_canvas(canvas).await;
56 | 
57 |   // act
58 |   wgpu_layers::render(get_view_matrix(), vec![CANVAS_SIZE.0, CANVAS_SIZE.1]);
59 |   timeout(1500).await; // wait to render
60 | 
61 |   // assert
62 |   let image_data = get_canvas_image_data(canvas).await;
63 |   let image = pdqhash::image::load_from_memory(&image_data[..]).unwrap();
64 |   let (hash, _) = pdqhash::generate_pdq_full_size(&image);
65 | 
66 |   assert_eq!(
67 |     [
68 |       171, 170, 84, 117, 171, 170, 84, 81, 171, 138, 84, 84, 171, 170, 171, 138, 171, 138, 84, 81,
69 |       85, 255, 84, 113, 171, 174, 84, 84, 171, 170, 84, 85
70 |     ],
71 |     hash
72 |   );
73 | }
74 | 


--------------------------------------------------------------------------------
/.github/actions/prepare-build-env/action.yml:
--------------------------------------------------------------------------------
 1 | name: Prepare build environment
 2 | description: Ensures that everything is prepared for our build jobs
 3 | 
 4 | outputs:
 5 |   cargo-cache-primary-key:
 6 |     description: Primary key of cargo cache restore action
 7 |     value: ${{ steps.cargo-cache.outputs.cache-primary-key }}
 8 |   cargo-cache-hit:
 9 |     description: A boolean value to indicate an exact match was found for the cargo cache restore action
10 |     value: ${{ steps.cargo-cache.outputs.cache-hit }}
11 | 
12 | runs:
13 |   using: "composite"
14 |   steps:
15 |     - name: Use protobuf-compiler latest
16 |       shell: bash
17 |       run: sudo apt-get install -y protobuf-compiler
18 | 
19 |     - name: Use wasm-pack latest
20 |       shell: bash
21 |       run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
22 | 
23 |     - name: Use brotli latest
24 |       shell: bash
25 |       run: sudo apt-get install -y brotli
26 | 
27 |     - name: Cache rust-toolchain (restore)
28 |       id: rustup-cache
29 |       uses: actions/cache/restore@v4.2.4
30 |       with:
31 |        path: |
32 |          ~/.rustup/toolchains
33 |          ~/.rustup/update-hashes
34 |          ~/.rustup/settings.toml
35 |        key: toolchain-${{ hashFiles('rust-toolchain') }}-1
36 | 
37 |     - name: Use rust-toolchain nightly
38 |       if: steps.rustup-cache.outputs.cache-hit != 'true'
39 |       shell: bash
40 |       run: |
41 |         rustup toolchain uninstall stable
42 |         rustup show # force install of rust-toolchain TOML
43 | 
44 |     - name: Get rust version
45 |       id: rustup
46 |       shell: bash
47 |       run: |
48 |         rustup show
49 |         echo "version=$(rustc --version | cut -d ' ' -f 2)" >> $GITHUB_OUTPUT
50 | 
51 |     - name: Cache rust-toolchain (save)
52 |       uses: actions/cache/save@v4.2.4
53 |       if: steps.rustup-cache.outputs.cache-hit != 'true' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop')
54 |       with:
55 |         path: |
56 |           ~/.rustup/toolchains
57 |           ~/.rustup/update-hashes
58 |           ~/.rustup/settings.toml
59 |         key: ${{ steps.rustup-cache.outputs.cache-primary-key }}
60 | 
61 |     - name: Cache cargo output (restore)
62 |       id: cargo-cache
63 |       uses: actions/cache/restore@v4.2.4
64 |       with:
65 |         path: |
66 |           ~/.cargo/bin/
67 |           ~/.cargo/.crates.toml
68 |           ~/.cargo/.crates2.json
69 |           ~/.cargo/.package-cache
70 |           ~/.cargo/registry/
71 |           ~/.cargo/git/db/
72 |           target/
73 |         key: ${{ runner.os }}-${{ steps.rustup.outputs.version }}-cargo-${{ hashFiles('**/Cargo.lock') }}-${{ github.job }}-1
74 | 


--------------------------------------------------------------------------------
/src/ressource/material/shader/common.wgsl:
--------------------------------------------------------------------------------
 1 | struct Tile {
 2 |   model_view_matrix: mat4x4<f32>,
 3 |   clipping_rect: vec4<f32>,
 4 | }
 5 | 
 6 | struct View {
 7 |   view_matrix: mat4x4<f32>,
 8 |   width: u32,
 9 |   height: u32,
10 | }
11 | 
12 | struct Style {
13 |   fill_color: vec4<f32>,
14 |   stroke_color: vec4<f32>,
15 |   stroke_width: f32,
16 | }
17 | 
18 | struct VertexInput {
19 |   @location(0) position: vec2<f32>,
20 |   @location(1) normal: vec2<f32>,
21 | }
22 | 
23 | struct FragmentOutput {
24 |   @location(0) color: vec4<f32>,
25 |   @builtin(sample_mask) mask_out: u32,
26 | }
27 | 
28 | struct FragmentInput {
29 |   @builtin(position) position: vec4<f32>,
30 |   @location(0) @interpolate(linear, center) normal: vec2<f32>,
31 | }
32 | 
33 | @group(0) @binding(0)
34 | var<uniform> view: View;
35 | 
36 | @group(1) @binding(0)
37 | var<uniform> style: Style;
38 | 
39 | @group(2) @binding(0)
40 | var<uniform> tile: Tile;
41 | 
42 | const GLOBAL_SCALE: f32 = 0.0032; // can this be calculated?
43 | 
44 | @vertex
45 | fn vs_fill(
46 |   @location(0) pos: vec2<f32>
47 | ) -> @builtin(position) vec4<f32> {
48 |   return tile.model_view_matrix * vec4<f32>(pos, 0.0, 1.0);
49 | }
50 | 
51 | @vertex
52 | fn vs_stroke(vertex: VertexInput) -> FragmentInput {
53 |   // TODO: precalculate (scale * GLOBAL_SCALE * style.stroke_width) on cpu
54 |   var scale = 1.0 / (view.view_matrix[0][0] * f32(view.width));
55 |   var delta = vec2<f32>(vertex.normal * scale * GLOBAL_SCALE * style.stroke_width);
56 |   var position = tile.model_view_matrix * vec4<f32>(vertex.position + delta, 0.0, 1.0);
57 |   return FragmentInput(position, vertex.normal);
58 | }
59 | 
60 | @vertex
61 | fn vs_point(@location(0) pos: vec2<f32>, @location(1) point_location: vec2<f32>) -> @builtin(position) vec4<f32> {
62 |   var scale = 1.0 / (view.view_matrix[0][0] * f32(view.width));
63 |   return tile.model_view_matrix * vec4<f32>((pos * 0.02 * scale) + point_location, 0.0, 1.0);
64 | }
65 | 
66 | fn clipping_and_premul_alpha(position: vec4<f32>, input_color: vec4<f32>) -> FragmentOutput {
67 |   var color = input_color.a * vec4<f32>(input_color.rgb, 1.0); // pre-multiplied alpha
68 |   var fragment_output = FragmentOutput(color, 0xFFFFFFFFu);
69 | 
70 |   if (
71 |     position.x < tile.clipping_rect[0] ||
72 |     position.y < tile.clipping_rect[1] ||
73 |     position.x > tile.clipping_rect[2] ||
74 |     position.y > tile.clipping_rect[3]
75 |   ) {
76 |     fragment_output.mask_out = 0u;
77 |   }
78 |   return fragment_output;
79 | }
80 | 
81 | @fragment
82 | fn fs_fill(@builtin(position) position: vec4<f32>) -> FragmentOutput {
83 |   return clipping_and_premul_alpha(position, style.fill_color);
84 | }
85 | 
86 | @fragment
87 | fn fs_stroke(input: FragmentInput) -> FragmentOutput {
88 |   var distance = length(input.normal);
89 |   var blur = 0.8;
90 |   var alpha = (1.0 - distance) / (blur / style.stroke_width);
91 |   var color = vec4<f32>(style.stroke_color.rgb, alpha);
92 |   return clipping_and_premul_alpha(input.position, color);
93 | }


--------------------------------------------------------------------------------
/demo/src/worker.js:
--------------------------------------------------------------------------------
  1 | import init, { initThreadPool, startWithOffscreenCanvas, render, addPbfTileData } from 'wgpu-layers'
  2 | import { create, makeInverse } from 'ol/transform'
  3 | 
  4 | import { READY, STARTED, CANVAS, SHARED_ARRAY_BUFFER, PBF_DATA } from './types'
  5 | 
  6 | let shared_state, ready = false
  7 | 
  8 | self.onmessage = async ({ data: { type, payload } }) => {
  9 |   switch (type) {
 10 |     case CANVAS:
 11 |       await startWithOffscreenCanvas(payload.canvas)
 12 |       self.postMessage({ type: STARTED })
 13 |       ready = true
 14 |       loop()
 15 |       break
 16 |     case SHARED_ARRAY_BUFFER:
 17 |       shared_state = payload
 18 |       break
 19 |     case PBF_DATA:
 20 |       const { data, tileCoord, extent } = payload
 21 |       if (ready) {
 22 |         await addPbfTileData(new Uint8Array(data), tileCoord, extent)
 23 |       }
 24 |       break
 25 |   }
 26 | }
 27 | 
 28 | function loop() {
 29 |   Atomics.wait(new Int32Array(shared_state), 6, 0) // wait until notify
 30 | 
 31 |   const { size, viewState } = getFrameState()
 32 | 
 33 |   const [width, height] = size
 34 |   render(
 35 |     getViewMatrix(viewState, width, height),
 36 |     size
 37 |   )
 38 | 
 39 |   setTimeout(loop)
 40 | }
 41 | 
 42 | function getFrameState() {
 43 |   const slice = new Uint32Array(shared_state)
 44 | 
 45 |   const buffer = new ArrayBuffer(shared_state.byteLength)
 46 |   const f32_buffer = new Float32Array(buffer)
 47 |   const uint32_buffer = new Uint32Array(buffer)
 48 | 
 49 |   for (let i = 0; i < uint32_buffer.length; i++) {
 50 |     uint32_buffer[i] = Atomics.load(slice, i)
 51 |   }
 52 | 
 53 |   return {
 54 |     size: [uint32_buffer[0], uint32_buffer[1]],
 55 |     viewState: {
 56 |       center: [f32_buffer[2], f32_buffer[3]],
 57 |       resolution: f32_buffer[4],
 58 |       rotation: f32_buffer[5]
 59 |     }
 60 |   }
 61 | }
 62 | 
 63 | function getViewMatrix(viewState, width, height) {
 64 |   const halfWidth = width * .5
 65 |   const halfHeight = height * .5
 66 | 
 67 |   const scaleX = viewState.resolution * halfWidth
 68 |   const scaleY = viewState.resolution * halfHeight
 69 | 
 70 |   const viewTransform = create()
 71 | 
 72 |   const sin = Math.sin(viewState.rotation)
 73 |   const cos = Math.cos(viewState.rotation)
 74 | 
 75 |   viewTransform[0] = scaleX * cos
 76 |   viewTransform[1] = scaleX * sin
 77 |   viewTransform[2] = scaleY * -sin
 78 |   viewTransform[3] = scaleY * cos
 79 |   viewTransform[4] = viewState.center[0]
 80 |   viewTransform[5] = viewState.center[1]
 81 | 
 82 |   const viewMatrix = makeInverse(
 83 |     create(),
 84 |     viewTransform
 85 |   )
 86 | 
 87 |   return [
 88 |     viewMatrix[0], viewMatrix[1], 0.0, 0.0,
 89 |     viewMatrix[2], viewMatrix[3], 0.0, 0.0,
 90 |     0.0, 0.0, 1.0, 0.0,
 91 |     viewMatrix[4], viewMatrix[5], 0.0, 1.0
 92 |   ]
 93 | }
 94 | 
 95 | async function run() {
 96 |   await init()
 97 |   await initThreadPool(navigator.hardwareConcurrency - 1)
 98 | 
 99 |   self.postMessage({ type: READY })
100 | }
101 | 
102 | run()
103 | 


--------------------------------------------------------------------------------
/src/ressource/tile/point.rs:
--------------------------------------------------------------------------------
 1 | use geo_types::Geometry::{MultiPoint, Point};
 2 | use log::info;
 3 | use mvt_reader::feature::Feature;
 4 | 
 5 | use crate::ressource::{BindGroupScope, RessourceManager, material::MaterialType};
 6 | 
 7 | use super::{Bucket, BucketType, Tile, TileUniform};
 8 | 
 9 | const DIMENSIONS: usize = 2;
10 | 
11 | const RECT_VERTEX_BUFFER: [f32; 8] = [-0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5];
12 | const RECT_INDICES_BUFFER: [u32; 6] = [0, 1, 2, 2, 3, 0];
13 | 
14 | impl<F> Bucket<F, { BucketType::Point }> for Tile {
15 |   fn new(ressource_manager: &RessourceManager, extent: [f32; 4]) -> Self {
16 |     let tile_uniform = TileUniform::default();
17 |     let tile_uniform_buffer =
18 |       ressource_manager.create_buffer_init(&wgpu::util::BufferInitDescriptor {
19 |         label: None,
20 |         contents: bytemuck::cast_slice(&[tile_uniform]),
21 |         usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
22 |       });
23 |     let bind_group =
24 |       ressource_manager.create_bind_group(&BindGroupScope::Model, &[wgpu::BindGroupEntry {
25 |         binding: 0,
26 |         resource: tile_uniform_buffer.as_entire_binding(),
27 |       }]);
28 | 
29 |     let vertex_wgpu_buffer = Some(ressource_manager.create_buffer_init(
30 |       &wgpu::util::BufferInitDescriptor {
31 |         label: None,
32 |         contents: bytemuck::cast_slice(&RECT_VERTEX_BUFFER),
33 |         usage: wgpu::BufferUsages::VERTEX,
34 |       },
35 |     ));
36 | 
37 |     let index_wgpu_buffer = Some(ressource_manager.create_buffer_init(
38 |       &wgpu::util::BufferInitDescriptor {
39 |         label: None,
40 |         contents: bytemuck::cast_slice(&RECT_INDICES_BUFFER),
41 |         usage: wgpu::BufferUsages::INDEX,
42 |       },
43 |     ));
44 | 
45 |     Self {
46 |       material: ressource_manager.get_material(MaterialType::Point),
47 |       bind_group,
48 |       tile_uniform_buffer,
49 |       vertex_wgpu_buffer,
50 |       vertex_buffer: Vec::with_capacity(0),
51 |       index_wgpu_buffer,
52 |       index_buffer: Vec::with_capacity(0),
53 |       instance_wgpu_buffer: None,
54 |       extent,
55 |       bucket_type: BucketType::Point,
56 |     }
57 |   }
58 | 
59 |   fn add_features(&mut self, features: &mut Vec<Feature>, ressource_manager: &RessourceManager) {
60 |     for feature in features.iter() {
61 |       match feature.get_geometry() {
62 |         Point(point) => {
63 |           let mut vertices = Vec::with_capacity(DIMENSIONS);
64 |           vertices.push(point.x());
65 |           vertices.push(point.y());
66 |           self.vertex_buffer.append(&mut vertices);
67 |         }
68 |         MultiPoint(multi_point) => {
69 |           let mut vertices = Vec::with_capacity(multi_point.0.len() * DIMENSIONS);
70 |           for point in multi_point.iter() {
71 |             vertices.push(point.x());
72 |             vertices.push(point.y());
73 |           }
74 |           self.vertex_buffer.append(&mut vertices);
75 |         }
76 |         _ => {
77 |           info!("Geometry type currently not supported");
78 |         }
79 |       }
80 |     }
81 | 
82 |     self.instance_wgpu_buffer = Some(ressource_manager.create_buffer_init(
83 |       &wgpu::util::BufferInitDescriptor {
84 |         label: None,
85 |         contents: bytemuck::cast_slice(&self.vertex_buffer),
86 |         usage: wgpu::BufferUsages::VERTEX,
87 |       },
88 |     ));
89 |   }
90 | }
91 | 


--------------------------------------------------------------------------------
/src/ressource/view.rs:
--------------------------------------------------------------------------------
  1 | use std::mem;
  2 | 
  3 | use super::{BindGroupScope, RessourceManager};
  4 | 
  5 | #[repr(C)]
  6 | #[derive(Copy, Clone, bytemuck_derive::Pod, bytemuck_derive::Zeroable)]
  7 | struct ViewBuffer {
  8 |   /// transformation matrix world-space to view-space
  9 |   view_matrix: glam::Mat4,
 10 | 
 11 |   width: u32,
 12 | 
 13 |   height: u32,
 14 | 
 15 |   _pad: [u32; 2],
 16 | }
 17 | 
 18 | pub struct View {
 19 |   bind_group: wgpu::BindGroup,
 20 | 
 21 |   /// width of surface
 22 |   width: u32,
 23 | 
 24 |   /// height of surface
 25 |   height: u32,
 26 | 
 27 |   /// half width of surface
 28 |   half_width: f32,
 29 | 
 30 |   /// half height of surface
 31 |   half_height: f32,
 32 | 
 33 |   view_buffer: ViewBuffer,
 34 | 
 35 |   view_matrix_buffer: wgpu::Buffer,
 36 | }
 37 | 
 38 | impl View {
 39 |   pub fn new((width, height): (u32, u32), ressource_manager: &mut RessourceManager) -> Self {
 40 |     let view_matrix = ViewBuffer {
 41 |       view_matrix: glam::Mat4::IDENTITY,
 42 |       width,
 43 |       height,
 44 |       _pad: [0, 0],
 45 |     };
 46 |     let view_matrix_buffer =
 47 |       ressource_manager.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 48 |         label: None,
 49 |         contents: bytemuck::cast_slice(&[view_matrix]),
 50 |         usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
 51 |       });
 52 | 
 53 |     ressource_manager.register_bind_group_layout(
 54 |       BindGroupScope::Global,
 55 |       &wgpu::BindGroupLayoutDescriptor {
 56 |         label: None,
 57 |         entries: &[wgpu::BindGroupLayoutEntry {
 58 |           binding: 0,
 59 |           visibility: wgpu::ShaderStages::VERTEX,
 60 |           ty: wgpu::BindingType::Buffer {
 61 |             ty: wgpu::BufferBindingType::Uniform,
 62 |             has_dynamic_offset: false,
 63 |             min_binding_size: wgpu::BufferSize::new(mem::size_of::<ViewBuffer>() as _),
 64 |           },
 65 |           count: None,
 66 |         }],
 67 |       },
 68 |     );
 69 | 
 70 |     let bind_group =
 71 |       ressource_manager.create_bind_group(&BindGroupScope::Global, &[wgpu::BindGroupEntry {
 72 |         binding: 0,
 73 |         resource: view_matrix_buffer.as_entire_binding(),
 74 |       }]);
 75 | 
 76 |     Self {
 77 |       bind_group,
 78 |       width,
 79 |       height,
 80 |       half_width: width as f32 * 0.5,
 81 |       half_height: height as f32 * 0.5,
 82 |       view_buffer: view_matrix,
 83 |       view_matrix_buffer,
 84 |     }
 85 |   }
 86 | 
 87 |   pub fn set<'frame>(
 88 |     &'frame self,
 89 |     render_pass: &mut wgpu::RenderPass<'frame>,
 90 |     queue: &wgpu::Queue,
 91 |   ) {
 92 |     render_pass.set_bind_group(BindGroupScope::Global as u32, Some(&self.bind_group), &[]);
 93 | 
 94 |     queue.write_buffer(
 95 |       &self.view_matrix_buffer,
 96 |       0,
 97 |       bytemuck::cast_slice(&[self.view_buffer]),
 98 |     );
 99 |   }
100 | 
101 |   pub fn set_size(&mut self, (width, height): (u32, u32)) {
102 |     self.width = width;
103 |     self.height = height;
104 |     self.half_width = width as f32 * 0.5;
105 |     self.half_height = height as f32 * 0.5;
106 |     self.view_buffer.width = width;
107 |     self.view_buffer.height = height;
108 |   }
109 | 
110 |   pub fn set_view_matrix(&mut self, view_matrix: glam::Mat4) {
111 |     self.view_buffer.view_matrix = view_matrix;
112 |   }
113 | 
114 |   pub fn get_view_matrix(&self) -> glam::Mat4 {
115 |     self.view_buffer.view_matrix
116 |   }
117 | 
118 |   pub fn get_size(&self) -> (u32, u32) {
119 |     (self.width, self.height)
120 |   }
121 | 
122 |   pub fn get_half_size(&self) -> (f32, f32) {
123 |     (self.half_width, self.half_height)
124 |   }
125 | }
126 | 


--------------------------------------------------------------------------------
/src/ressource/material/mod.rs:
--------------------------------------------------------------------------------
  1 | use std::{collections::HashMap, marker::ConstParamTy, mem, sync::Arc};
  2 | 
  3 | use super::{BindGroupScope, RessourceManager, ShaderModuleScope};
  4 | 
  5 | mod fill;
  6 | mod line;
  7 | mod point;
  8 | 
  9 | #[repr(C)]
 10 | #[derive(Copy, Clone, bytemuck_derive::Pod, bytemuck_derive::Zeroable)]
 11 | struct Style {
 12 |   /// fill color
 13 |   fill_color: [f32; 4],
 14 | 
 15 |   /// stroke color
 16 |   stroke_color: [f32; 4],
 17 | 
 18 |   /// stroke width
 19 |   stroke_width: f32,
 20 | 
 21 |   _pad: [u32; 3],
 22 | }
 23 | 
 24 | #[derive(PartialEq, Eq, Hash, Clone, ConstParamTy)]
 25 | pub enum MaterialType {
 26 |   Fill,
 27 |   Line,
 28 |   Point,
 29 | }
 30 | 
 31 | pub struct Material {
 32 |   /// wgpu pipeline
 33 |   pipeline: wgpu::RenderPipeline,
 34 | 
 35 |   /// wgpu bind group
 36 |   bind_group: wgpu::BindGroup,
 37 | }
 38 | 
 39 | impl Material {
 40 |   pub fn set<'frame>(&'frame self, render_pass: &mut wgpu::RenderPass<'frame>) {
 41 |     render_pass.set_pipeline(&self.pipeline);
 42 |     render_pass.set_bind_group(BindGroupScope::Material as u32, Some(&self.bind_group), &[]);
 43 |   }
 44 | }
 45 | 
 46 | pub trait CreatePipeline<const T: MaterialType>
 47 | where
 48 |   Self: Sized,
 49 | {
 50 |   fn new(ressource_manager: &RessourceManager, shader_module: &wgpu::ShaderModule) -> Self;
 51 | }
 52 | 
 53 | pub struct MaterialManager {
 54 |   shader_module: wgpu::ShaderModule,
 55 | 
 56 |   materials: HashMap<MaterialType, Arc<Material>>,
 57 | }
 58 | 
 59 | impl MaterialManager {
 60 |   pub fn new(ressource_manager: &mut RessourceManager) -> Self {
 61 |     let shader_module = ressource_manager.create_shader_module(
 62 |       ShaderModuleScope::Common,
 63 |       std::borrow::Cow::Borrowed(include_str!("shader/common.wgsl")),
 64 |     );
 65 | 
 66 |     ressource_manager.register_bind_group_layout(
 67 |       BindGroupScope::Material,
 68 |       &wgpu::BindGroupLayoutDescriptor {
 69 |         label: None,
 70 |         entries: &[wgpu::BindGroupLayoutEntry {
 71 |           binding: 0,
 72 |           visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
 73 |           ty: wgpu::BindingType::Buffer {
 74 |             ty: wgpu::BufferBindingType::Uniform,
 75 |             has_dynamic_offset: false,
 76 |             min_binding_size: wgpu::BufferSize::new(mem::size_of::<Style>() as _),
 77 |           },
 78 |           count: None,
 79 |         }],
 80 |       },
 81 |     );
 82 | 
 83 |     Self {
 84 |       shader_module,
 85 |       materials: HashMap::new(),
 86 |     }
 87 |   }
 88 | 
 89 |   pub fn get(
 90 |     &mut self,
 91 |     ressource_manager: &RessourceManager,
 92 |     material_type: MaterialType,
 93 |   ) -> Arc<Material> {
 94 |     let material = self
 95 |       .materials
 96 |       .entry(material_type.clone())
 97 |       .or_insert(match material_type {
 98 |         MaterialType::Fill =>
 99 |         {
100 |           #[allow(clippy::arc_with_non_send_sync)]
101 |           Arc::new(<Material as CreatePipeline<{ MaterialType::Fill }>>::new(
102 |             ressource_manager,
103 |             &self.shader_module,
104 |           ))
105 |         }
106 |         MaterialType::Line =>
107 |         {
108 |           #[allow(clippy::arc_with_non_send_sync)]
109 |           Arc::new(<Material as CreatePipeline<{ MaterialType::Line }>>::new(
110 |             ressource_manager,
111 |             &self.shader_module,
112 |           ))
113 |         }
114 |         MaterialType::Point =>
115 |         {
116 |           #[allow(clippy::arc_with_non_send_sync)]
117 |           Arc::new(<Material as CreatePipeline<{ MaterialType::Point }>>::new(
118 |             ressource_manager,
119 |             &self.shader_module,
120 |           ))
121 |         }
122 |       });
123 |     material.clone()
124 |   }
125 | }
126 | 


--------------------------------------------------------------------------------
/tests/utils.rs:
--------------------------------------------------------------------------------
  1 | #![allow(unused_attributes)]
  2 | #![feature(thread_local)]
  3 | #![cfg(target_arch = "wasm32")]
  4 | 
  5 | use std::cell::RefCell;
  6 | use std::sync::Once;
  7 | use wasm_bindgen::prelude::*;
  8 | use wasm_bindgen::JsCast;
  9 | use wasm_bindgen_futures::JsFuture;
 10 | use web_sys::HtmlCanvasElement;
 11 | 
 12 | pub const CANVAS_SIZE: (u32, u32) = (512, 512);
 13 | 
 14 | static INIT: Once = Once::new();
 15 | 
 16 | #[thread_local]
 17 | pub static CANVAS: RefCell<Option<web_sys::HtmlCanvasElement>> = RefCell::new(None);
 18 | 
 19 | pub fn initialize() {
 20 |   INIT.call_once(|| {
 21 |     // FIXME: testing multithreaded wasm is not possible for now, see: https://github.com/rustwasm/wasm-bindgen/issues/2892
 22 |     /*let _ = JsFuture::from(wasm_bindgen_rayon::init_thread_pool(
 23 |       web_sys::window()
 24 |         .unwrap()
 25 |         .navigator()
 26 |         .hardware_concurrency() as usize,
 27 |     ))
 28 |     .await;*/
 29 | 
 30 |     let document = web_sys::window().unwrap().document().unwrap();
 31 |     let canvas = document.create_element("canvas").unwrap();
 32 |     let canvas = canvas
 33 |       .dyn_into::<web_sys::HtmlElement>()
 34 |       .map_err(|_| ())
 35 |       .unwrap();
 36 | 
 37 |     let body = document.body().unwrap();
 38 |     let style = canvas.style();
 39 | 
 40 |     body.append_child(&canvas).unwrap();
 41 | 
 42 |     style.set_property("position", "absolute").unwrap();
 43 |     style.set_property("top", "1em").unwrap();
 44 |     style.set_property("right", "1em").unwrap();
 45 | 
 46 |     canvas.set_id("test");
 47 | 
 48 |     let canvas: web_sys::HtmlCanvasElement = canvas
 49 |       .dyn_into::<web_sys::HtmlCanvasElement>()
 50 |       .map_err(|_| ())
 51 |       .unwrap();
 52 | 
 53 |     let (width, height) = CANVAS_SIZE;
 54 |     canvas.set_width(width);
 55 |     canvas.set_height(height);
 56 | 
 57 |     *CANVAS.borrow_mut() = Some(canvas);
 58 |   });
 59 | }
 60 | 
 61 | pub async fn get_canvas_image_data(canvas: &HtmlCanvasElement) -> Vec<u8> {
 62 |   let promise = js_sys::Promise::new(&mut move |resolve, _| {
 63 |     let cb: Closure<dyn Fn(web_sys::Blob)> = Closure::wrap(Box::new(move |blob| {
 64 |       resolve.call1(&JsValue::NULL, &JsValue::from(blob)).unwrap();
 65 |     }));
 66 |     canvas.to_blob(cb.as_ref().unchecked_ref()).unwrap();
 67 |     cb.forget(); // leaking
 68 |   });
 69 | 
 70 |   let blob = JsFuture::from(promise).await.unwrap();
 71 |   let blob = web_sys::Blob::from(blob);
 72 | 
 73 |   let promise = js_sys::Promise::new(&mut move |resolve, _| {
 74 |     let file_reader = std::rc::Rc::new(web_sys::FileReader::new().unwrap());
 75 |     let file_reader_cb = file_reader.clone();
 76 | 
 77 |     let cb: Closure<dyn Fn(web_sys::Blob)> = Closure::wrap(Box::new(move |_| {
 78 |       let data_url = file_reader_cb.result().unwrap();
 79 |       resolve.call1(&JsValue::NULL, &data_url).unwrap();
 80 |     }));
 81 | 
 82 |     file_reader.set_onload(Some(cb.as_ref().unchecked_ref()));
 83 |     file_reader.read_as_array_buffer(&blob).unwrap();
 84 | 
 85 |     cb.forget(); // leaking
 86 |   });
 87 | 
 88 |   let buffer = js_sys::Uint8Array::new(&JsFuture::from(promise).await.unwrap());
 89 |   let mut result = vec![0; buffer.length() as usize];
 90 |   buffer.copy_to(&mut result[..]);
 91 | 
 92 |   result
 93 | }
 94 | 
 95 | pub async fn timeout(timeout: i32) {
 96 |   let promise = js_sys::Promise::new(&mut move |resolve, _| {
 97 |     let cb: Closure<dyn Fn()> = Closure::wrap(Box::new(move || {
 98 |       resolve.call0(&JsValue::NULL).unwrap();
 99 |     }));
100 |     web_sys::window()
101 |       .unwrap()
102 |       .set_timeout_with_callback_and_timeout_and_arguments_0(cb.as_ref().unchecked_ref(), timeout)
103 |       .unwrap();
104 |     cb.forget(); // leaking
105 |   });
106 |   JsFuture::from(promise).await.unwrap();
107 | }
108 | 
109 | #[rustfmt::skip]
110 | pub fn get_view_matrix() -> Vec<f32> {
111 |   vec![
112 |     7.713_025_5e-7, 0.0, 0.0, 0.0,
113 |     0.0, 7.713_025_5e-7, 0.0, 0.0,
114 |     0.0, 0.0, 1.0, 0.0,
115 |     -0.975_147_84, -4.825_174, 0.0, 1.0,
116 |   ]
117 | }
118 | 


--------------------------------------------------------------------------------
/src/ressource/tile/fill.rs:
--------------------------------------------------------------------------------
  1 | use geo_types::Geometry::{MultiPolygon, Polygon};
  2 | use log::{error, info};
  3 | use mvt_reader::feature::Feature;
  4 | 
  5 | use crate::ressource::{BindGroupScope, RessourceManager, material::MaterialType};
  6 | 
  7 | use super::{Bucket, BucketType, Tile, TileUniform};
  8 | 
  9 | const DIMENSIONS: usize = 2;
 10 | 
 11 | impl Tile {
 12 |   fn add_polygon(&mut self, polygon: &geo_types::Polygon<f32>) {
 13 |     let exterior = polygon.exterior();
 14 |     let interior = polygon.interiors();
 15 |     let mut vertex_count = exterior.0.len() - 1;
 16 |     let mut rings = Vec::with_capacity(1 + interior.len());
 17 |     rings.push(exterior);
 18 |     interior.iter().for_each(|r| {
 19 |       rings.push(r);
 20 |       // ignore last coordinate (closed ring)
 21 |       vertex_count += r.0.len() - 1;
 22 |     });
 23 |     let mut vertices = Vec::with_capacity(vertex_count * DIMENSIONS);
 24 |     let mut hole_indices = Vec::new();
 25 |     for (i, ring) in rings.iter().enumerate() {
 26 |       // ignore last coordinate (closed ring)
 27 |       let end = ring.0.len() - 1;
 28 |       let coordinate_slice = &ring.0[..end];
 29 |       for coord in coordinate_slice.iter() {
 30 |         vertices.push(coord.x);
 31 |         vertices.push(coord.y);
 32 |       }
 33 |       if i < rings.len() - 1 {
 34 |         hole_indices.push(vertices.len() / DIMENSIONS)
 35 |       }
 36 |     }
 37 | 
 38 |     let earcut_result = earcutr::earcut(&vertices, &hole_indices, DIMENSIONS);
 39 |     match earcut_result {
 40 |       Ok(indices) => {
 41 |         let offset = (self.vertex_buffer.len() / DIMENSIONS) as u32;
 42 |         self.vertex_buffer.append(&mut vertices);
 43 |         self
 44 |           .index_buffer
 45 |           .append(&mut indices.iter().map(|i| (*i as u32) + offset).collect());
 46 |       }
 47 |       Err(_) => {
 48 |         error!("earcut parsing error");
 49 |       }
 50 |     }
 51 |   }
 52 | }
 53 | 
 54 | impl<F> Bucket<F, { BucketType::Fill }> for Tile {
 55 |   fn new(ressource_manager: &RessourceManager, extent: [f32; 4]) -> Self {
 56 |     let tile_uniform = TileUniform::default();
 57 |     let tile_uniform_buffer =
 58 |       ressource_manager.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 59 |         label: None,
 60 |         contents: bytemuck::cast_slice(&[tile_uniform]),
 61 |         usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
 62 |       });
 63 |     let bind_group =
 64 |       ressource_manager.create_bind_group(&BindGroupScope::Model, &[wgpu::BindGroupEntry {
 65 |         binding: 0,
 66 |         resource: tile_uniform_buffer.as_entire_binding(),
 67 |       }]);
 68 | 
 69 |     Self {
 70 |       material: ressource_manager.get_material(MaterialType::Fill),
 71 |       bind_group,
 72 |       tile_uniform_buffer,
 73 |       vertex_wgpu_buffer: None,
 74 |       vertex_buffer: Vec::with_capacity(0),
 75 |       index_wgpu_buffer: None,
 76 |       index_buffer: Vec::with_capacity(0),
 77 |       instance_wgpu_buffer: None,
 78 |       extent,
 79 |       bucket_type: BucketType::Fill,
 80 |     }
 81 |   }
 82 | 
 83 |   fn add_features(&mut self, features: &mut Vec<Feature>, ressource_manager: &RessourceManager) {
 84 |     for feature in features.iter() {
 85 |       match feature.get_geometry() {
 86 |         Polygon(polygon) => {
 87 |           self.add_polygon(polygon);
 88 |         }
 89 |         MultiPolygon(multi_polygon) => {
 90 |           for polygon in multi_polygon.iter() {
 91 |             self.add_polygon(polygon);
 92 |           }
 93 |         }
 94 |         _ => {
 95 |           info!("Geometry type currently not supported");
 96 |         }
 97 |       }
 98 |     }
 99 | 
100 |     self.vertex_wgpu_buffer = Some(ressource_manager.create_buffer_init(
101 |       &wgpu::util::BufferInitDescriptor {
102 |         label: None,
103 |         contents: bytemuck::cast_slice(&self.vertex_buffer),
104 |         usage: wgpu::BufferUsages::VERTEX,
105 |       },
106 |     ));
107 | 
108 |     self.index_wgpu_buffer = Some(ressource_manager.create_buffer_init(
109 |       &wgpu::util::BufferInitDescriptor {
110 |         label: None,
111 |         contents: bytemuck::cast_slice(&self.index_buffer),
112 |         usage: wgpu::BufferUsages::INDEX,
113 |       },
114 |     ));
115 |   }
116 | }
117 | 


--------------------------------------------------------------------------------
/examples/window.rs:
--------------------------------------------------------------------------------
  1 | #[cfg(not(target_arch = "wasm32"))]
  2 | mod example {
  3 |   use log::info;
  4 |   use pollster::FutureExt;
  5 |   use std::sync::Arc;
  6 | 
  7 |   struct Application {
  8 |     window: Option<Arc<winit::window::Window>>,
  9 |     size: winit::dpi::PhysicalSize<u32>,
 10 |   }
 11 | 
 12 |   impl Application {
 13 |     fn new() -> Self {
 14 |       Self {
 15 |         window: None,
 16 |         size: winit::dpi::PhysicalSize::new(512, 512),
 17 |       }
 18 |     }
 19 |     fn create_window(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
 20 |       let window_attributes = winit::window::Window::default_attributes()
 21 |         .with_title("wgpu-map")
 22 |         //.with_transparent(true)
 23 |         .with_resizable(false)
 24 |         .with_min_inner_size(self.size)
 25 |         .with_max_inner_size(self.size)
 26 |         .with_inner_size(self.size);
 27 | 
 28 |       let window = event_loop
 29 |         .create_window(window_attributes)
 30 |         .expect("Window can't be created");
 31 | 
 32 |       self.window = Some(Arc::new(window));
 33 |     }
 34 |   }
 35 | 
 36 |   impl winit::application::ApplicationHandler for Application {
 37 |     fn resumed(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
 38 |       info!("Resumed");
 39 | 
 40 |       self.create_window(event_loop);
 41 | 
 42 |       wgpu_layers::init(self, (self.size.width, self.size.height)).block_on();
 43 |     }
 44 | 
 45 |     fn window_event(
 46 |       &mut self,
 47 |       event_loop: &winit::event_loop::ActiveEventLoop,
 48 |       _window_id: winit::window::WindowId,
 49 |       event: winit::event::WindowEvent,
 50 |     ) {
 51 |       match event {
 52 |         winit::event::WindowEvent::CloseRequested => event_loop.exit(),
 53 |         winit::event::WindowEvent::KeyboardInput {
 54 |           event:
 55 |             winit::event::KeyEvent {
 56 |               state: winit::event::ElementState::Pressed,
 57 |               logical_key,
 58 |               ..
 59 |             },
 60 |           ..
 61 |         } => match logical_key {
 62 |           winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter) => event_loop.exit(),
 63 |           winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowUp) => {}
 64 |           winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowDown) => {}
 65 |           winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowLeft) => {}
 66 |           winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowRight) => {}
 67 |           winit::keyboard::Key::Named(winit::keyboard::NamedKey::PageUp) => {}
 68 |           winit::keyboard::Key::Named(winit::keyboard::NamedKey::PageDown) => {}
 69 |           _ => (),
 70 |         },
 71 |         winit::event::WindowEvent::Resized(size) => {
 72 |           self.size = size;
 73 |         }
 74 |         winit::event::WindowEvent::RedrawRequested => {
 75 |           #[rustfmt::skip]
 76 |             let view_matrix = vec![
 77 |               1.15142285e-7, -0.0, 0.0, 0.0,
 78 |               0.0, 1.15142285e-7, 0.0, 0.0,
 79 |               -0.27666306, -0.7963807, 1.0, 0.0,
 80 |               0.0, 0.0, 0.0, 1.0,
 81 |             ];
 82 |           wgpu_layers::render(view_matrix, vec![self.size.width, self.size.height]);
 83 |         }
 84 |         _ => (),
 85 |       }
 86 |     }
 87 |   }
 88 | 
 89 |   impl wgpu_layers::renderer::ToSurface for Application {
 90 |     fn create_surface(
 91 |       &self,
 92 |       instance: &wgpu::Instance,
 93 |     ) -> Result<wgpu::Surface<'static>, wgpu::CreateSurfaceError> {
 94 |       instance.create_surface(wgpu::SurfaceTarget::Window(Box::new(
 95 |         <std::option::Option<std::sync::Arc<winit::window::Window>> as Clone>::clone(&self.window)
 96 |           .unwrap()
 97 |           .clone(),
 98 |       )))
 99 |     }
100 |   }
101 | 
102 |   pub fn main() {
103 |     env_logger::init_from_env(
104 |       env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
105 |     );
106 | 
107 |     let event_loop = winit::event_loop::EventLoop::new().unwrap();
108 |     let mut application = Application::new();
109 | 
110 |     let _ = event_loop.run_app(&mut application);
111 |   }
112 | }
113 | 
114 | fn main() {
115 |   #[cfg(not(target_arch = "wasm32"))]
116 |   example::main();
117 | }
118 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
  1 | name: CI
  2 | 
  3 | on:
  4 |   schedule:
  5 |     - cron: "0 7 * * 1"
  6 |   push:
  7 | 
  8 | env:
  9 |   CARGO_TERM_COLOR: always
 10 |   CARGO_INCREMENTAL: 0
 11 | 
 12 | permissions:
 13 |   contents: read
 14 | 
 15 | jobs:
 16 |   lint:
 17 |     timeout-minutes: 10
 18 |     runs-on: ubuntu-22.04
 19 |     steps:
 20 |       - name: Checkout repository and submodules
 21 |         uses: actions/checkout@v5.0.0
 22 |         with:
 23 |           submodules: recursive
 24 | 
 25 |       - name: Prepare build environemnt
 26 |         id: prepare
 27 |         uses: ./.github/actions/prepare-build-env
 28 | 
 29 |       - name: Run cargo clippy
 30 |         run: |
 31 |           cargo clippy --target wasm32-unknown-unknown \
 32 |             --tests --all-features -- --deny "warnings"
 33 | 
 34 |       - name: Post build environemnt
 35 |         if: always()
 36 |         uses: ./.github/actions/post-build-env
 37 |         with:
 38 |           cargo-cache-primary-key: ${{ steps.prepare.outputs.cargo-cache-primary-key }}
 39 |           cargo-cache-hit: ${{ steps.prepare.outputs.cargo-cache-hit }}
 40 | 
 41 |   build:
 42 |     timeout-minutes: 10
 43 |     runs-on: ubuntu-22.04
 44 |     steps:
 45 |       - name: Checkout repository and submodules
 46 |         uses: actions/checkout@v5.0.0
 47 |         with:
 48 |           submodules: recursive
 49 | 
 50 |       - name: Prepare build environemnt
 51 |         id: prepare
 52 |         uses: ./.github/actions/prepare-build-env
 53 | 
 54 |       - name: Run wasm-pack build
 55 |         run: wasm-pack build --release --target web
 56 | 
 57 |       - name: Run wasm-opt optimization
 58 |         run: |
 59 |           wget https://github.com/WebAssembly/binaryen/releases/download/version_123/binaryen-version_123-x86_64-linux.tar.gz
 60 |           tar zxf binaryen-version_123-x86_64-linux.tar.gz
 61 |           ./binaryen-version_123/bin/wasm-opt -Os -o pkg/wgpu_layers_bg.wasm pkg/wgpu_layers_bg.wasm
 62 | 
 63 |       - name: Check wasm artifact size
 64 |         run: |
 65 |           brotli -Z pkg/wgpu_layers_bg.wasm
 66 |           gzip -k pkg/wgpu_layers_bg.wasm
 67 |           ls -lh pkg/
 68 |           [[ $(stat -c %s pkg/wgpu_layers_bg.wasm.br) -lt 105000 ]]
 69 | 
 70 |       - name: Post build environemnt
 71 |         if: always()
 72 |         uses: ./.github/actions/post-build-env
 73 |         with:
 74 |           cargo-cache-primary-key: ${{ steps.prepare.outputs.cargo-cache-primary-key }}
 75 |           cargo-cache-hit: ${{ steps.prepare.outputs.cargo-cache-hit }}
 76 | 
 77 |   unit-test:
 78 |     timeout-minutes: 10
 79 |     runs-on: ubuntu-22.04
 80 |     steps:
 81 |       - name: Checkout repository and submodules
 82 |         uses: actions/checkout@v5.0.0
 83 |         with:
 84 |           submodules: recursive
 85 | 
 86 |       - name: Prepare build environemnt
 87 |         id: prepare
 88 |         uses: ./.github/actions/prepare-build-env
 89 | 
 90 |       - name: Use libegl1-mesa latest
 91 |         uses: ./.github/actions/install-graphics-driver
 92 | 
 93 |       - name: Run cargo test
 94 |         run: |
 95 |           cargo test --target `rustc -vV | sed -n 's|host: ||p'` -- --nocapture
 96 | 
 97 |       - name: Post build environemnt
 98 |         if: always()
 99 |         uses: ./.github/actions/post-build-env
100 |         with:
101 |           cargo-cache-primary-key: ${{ steps.prepare.outputs.cargo-cache-primary-key }}
102 |           cargo-cache-hit: ${{ steps.prepare.outputs.cargo-cache-hit }}
103 | 
104 |   integration-test:
105 |     timeout-minutes: 10
106 |     runs-on: ubuntu-22.04
107 |     strategy:
108 |       fail-fast: false
109 |       matrix:
110 |         browser: [firefox] # disable chrome for now
111 |     steps:
112 |       - name: Checkout repository and submodules
113 |         uses: actions/checkout@v5.0.0
114 |         with:
115 |           submodules: recursive
116 | 
117 |       - name: Prepare build environemnt
118 |         id: prepare
119 |         uses: ./.github/actions/prepare-build-env
120 | 
121 |       - name: Use libegl-mesa0 latest
122 |         uses: ./.github/actions/install-graphics-driver
123 | 
124 |       - name: Use firefox nightly
125 |         if: matrix.browser == 'firefox'
126 |         run: |
127 |           url=https://ftp.mozilla.org/pub/firefox/nightly/2025/07/2025-07-24-09-34-17-mozilla-central/
128 |           latest_version=$(curl -s $url | grep -o 'firefox-[0-9.]\+\.0a1\.en-US\.linux-x86_64\.tar\.xz' | sort -V | tail -n 1)
129 |           wget $url$latest_version
130 |           mkdir /tmp/firefox-nightly && tar -xf *.tar.xz -C /tmp/firefox-nightly
131 | 
132 |       - name: Print browser version
133 |         if: matrix.browser == 'chrome'
134 |         run: google-chrome --version
135 | 
136 |       - name: Run wasm-pack test
137 |         run: xvfb-run -a -s "-screen 0 1920x1080x24" wasm-pack test --${{ matrix.browser }} --headless --release --test '*'
138 | 
139 |       - name: Post build environemnt
140 |         if: always()
141 |         uses: ./.github/actions/post-build-env
142 |         with:
143 |           cargo-cache-primary-key: ${{ steps.prepare.outputs.cargo-cache-primary-key }}
144 |           cargo-cache-hit: ${{ steps.prepare.outputs.cargo-cache-hit }}
145 | 


--------------------------------------------------------------------------------
/src/ressource/mod.rs:
--------------------------------------------------------------------------------
  1 | use std::{borrow::Cow, cell::RefCell, collections::HashMap, sync::Arc};
  2 | 
  3 | use material::{Material, MaterialManager, MaterialType};
  4 | use wgpu::util::DeviceExt;
  5 | 
  6 | use self::tile::{Bucket, BucketType, Tile, TileManager};
  7 | 
  8 | mod material;
  9 | pub mod tile;
 10 | pub mod view;
 11 | 
 12 | #[derive(Eq, Hash, PartialEq)]
 13 | enum BindGroupScope {
 14 |   Global = 0,
 15 |   Material = 1,
 16 |   Model = 2,
 17 | }
 18 | 
 19 | impl BindGroupScope {
 20 |   pub fn value(&self) -> usize {
 21 |     match self {
 22 |       BindGroupScope::Global => BindGroupScope::Global as usize,
 23 |       BindGroupScope::Material => BindGroupScope::Material as usize,
 24 |       BindGroupScope::Model => BindGroupScope::Model as usize,
 25 |     }
 26 |   }
 27 | }
 28 | 
 29 | #[derive(Eq, Hash, PartialEq)]
 30 | enum ShaderModuleScope {
 31 |   Common,
 32 | }
 33 | 
 34 | // help to manage wgpu ressources
 35 | pub struct RessourceManager {
 36 |   device: wgpu::Device,
 37 | 
 38 |   texture_format: wgpu::TextureFormat,
 39 | 
 40 |   material_manager: Option<RefCell<MaterialManager>>,
 41 | 
 42 |   tile_manager: Option<RefCell<TileManager>>,
 43 | 
 44 |   bind_group_layouts: [wgpu::BindGroupLayout; 3],
 45 | 
 46 |   shader_modules: HashMap<ShaderModuleScope, wgpu::ShaderModule>,
 47 | }
 48 | 
 49 | impl RessourceManager {
 50 |   pub fn new(device: wgpu::Device, texture_format: wgpu::TextureFormat) -> Self {
 51 |     let empty_desc = &wgpu::BindGroupLayoutDescriptor {
 52 |       label: None,
 53 |       entries: &[],
 54 |     };
 55 |     let bind_group_layouts = [
 56 |       device.create_bind_group_layout(empty_desc),
 57 |       device.create_bind_group_layout(empty_desc),
 58 |       device.create_bind_group_layout(empty_desc),
 59 |     ];
 60 |     let mut manager = Self {
 61 |       device,
 62 |       texture_format,
 63 |       material_manager: None,
 64 |       tile_manager: None,
 65 |       bind_group_layouts,
 66 |       shader_modules: HashMap::new(),
 67 |     };
 68 |     manager.material_manager = Some(RefCell::new(MaterialManager::new(&mut manager)));
 69 |     manager.tile_manager = Some(RefCell::new(TileManager::new(&mut manager)));
 70 |     manager
 71 |   }
 72 | 
 73 |   pub(self) fn create_shader_module(
 74 |     &mut self,
 75 |     scope: ShaderModuleScope,
 76 |     code: Cow<str>,
 77 |   ) -> wgpu::ShaderModule {
 78 |     #[allow(clippy::arc_with_non_send_sync)]
 79 |     let shader_module = self
 80 |       .device
 81 |       .create_shader_module(wgpu::ShaderModuleDescriptor {
 82 |         label: None,
 83 |         source: wgpu::ShaderSource::Wgsl(code),
 84 |       });
 85 |     let result = shader_module.clone();
 86 |     self.shader_modules.insert(scope, shader_module);
 87 |     result
 88 |   }
 89 | 
 90 |   pub(self) fn create_bind_group(
 91 |     &self,
 92 |     scope: &BindGroupScope,
 93 |     entries: &[wgpu::BindGroupEntry],
 94 |   ) -> wgpu::BindGroup {
 95 |     self.device.create_bind_group(&wgpu::BindGroupDescriptor {
 96 |       label: None,
 97 |       layout: &self.bind_group_layouts[scope.value()],
 98 |       entries,
 99 |     })
100 |   }
101 | 
102 |   pub(self) fn create_buffer_init(&self, desc: &wgpu::util::BufferInitDescriptor) -> wgpu::Buffer {
103 |     self.device.create_buffer_init(desc)
104 |   }
105 | 
106 |   pub(self) fn create_render_pipeline(
107 |     &self,
108 |     vertex_state: wgpu::VertexState,
109 |     fragment_state: wgpu::FragmentState,
110 |   ) -> wgpu::RenderPipeline {
111 |     let pipeline_layout = self
112 |       .device
113 |       .create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
114 |         label: None,
115 |         bind_group_layouts: &[
116 |           &self.bind_group_layouts[0],
117 |           &self.bind_group_layouts[1],
118 |           &self.bind_group_layouts[2],
119 |         ],
120 |         push_constant_ranges: &[],
121 |       });
122 |     self
123 |       .device
124 |       .create_render_pipeline(&wgpu::RenderPipelineDescriptor {
125 |         label: None,
126 |         layout: Some(&pipeline_layout),
127 |         vertex: vertex_state,
128 |         fragment: Some(fragment_state),
129 |         primitive: wgpu::PrimitiveState::default(),
130 |         multisample: wgpu::MultisampleState::default(),
131 |         depth_stencil: None,
132 |         multiview: None,
133 |         cache: None,
134 |       })
135 |   }
136 | 
137 |   pub(self) fn register_bind_group_layout(
138 |     &mut self,
139 |     scope: BindGroupScope,
140 |     desc: &wgpu::BindGroupLayoutDescriptor,
141 |   ) {
142 |     self.bind_group_layouts[scope.value()] = self.device.create_bind_group_layout(desc);
143 |   }
144 | 
145 |   pub fn create_tile<F>(&self, bucket_type: BucketType, extent: [f32; 4]) -> Tile {
146 |     match bucket_type {
147 |       BucketType::Fill => Bucket::<F, { BucketType::Fill }>::new(self, extent),
148 |       BucketType::Line => Bucket::<F, { BucketType::Line }>::new(self, extent),
149 |       BucketType::Point => Bucket::<F, { BucketType::Point }>::new(self, extent),
150 |     }
151 |   }
152 | 
153 |   fn get_material(&self, material_type: MaterialType) -> Arc<Material> {
154 |     self
155 |       .material_manager
156 |       .as_ref()
157 |       .unwrap()
158 |       .borrow_mut()
159 |       .get(self, material_type)
160 |   }
161 | }
162 | 


--------------------------------------------------------------------------------
/demo/src/OffscreenTileLayer.js:
--------------------------------------------------------------------------------
  1 | import { Tile } from 'ol/layer'
  2 | import { getUid } from 'ol/util'
  3 | import TileState from 'ol/TileState'
  4 | import { READY, STARTED, CANVAS, SHARED_ARRAY_BUFFER, PBF_DATA } from './types'
  5 | 
  6 | export class OffscreenTileLayer extends Tile {
  7 |   constructor(opt_options) {
  8 |     super(opt_options)
  9 |     this.queue = []
 10 |     this.shared_state = new SharedArrayBuffer(7 * Uint32Array.BYTES_PER_ELEMENT)
 11 |   }
 12 | 
 13 |   createContainer() {
 14 |     const container = document.createElement('div')
 15 |     container.style.position = 'absolute'
 16 |     container.style.width = '100%'
 17 |     container.style.height = '100%'
 18 |     const offscreenCanvas = document.createElement('canvas')
 19 |     offscreenCanvas.style.display = 'block'
 20 |     offscreenCanvas.style.position = 'absolute'
 21 |     offscreenCanvas.style.width = '100%'
 22 |     offscreenCanvas.style.height = '100%'
 23 |     container.appendChild(offscreenCanvas)
 24 | 
 25 |     this.offscreenCanvas = offscreenCanvas
 26 | 
 27 |     this.worker = new Worker(new URL('./worker', import.meta.url), {
 28 |       type: 'module'
 29 |     })
 30 | 
 31 |     this.worker.postMessage({
 32 |       type: SHARED_ARRAY_BUFFER,
 33 |       payload: this.shared_state
 34 |     })
 35 | 
 36 |     this.worker.onmessage = async ({ data: { type } }) => {
 37 |       switch (type) {
 38 |         case READY:
 39 |           const offscreen = offscreenCanvas.transferControlToOffscreen()
 40 | 
 41 |           this.worker.postMessage({
 42 |             type: CANVAS, payload: {
 43 |               canvas: offscreen
 44 |             }
 45 |           }, [offscreen])
 46 |           break
 47 |         case STARTED:
 48 |           this.queue.forEach(task => task())
 49 |           this.queue = []
 50 |           this.ready = true
 51 |           break
 52 |       }
 53 |     }
 54 | 
 55 |     return container
 56 |   }
 57 | 
 58 |   createRenderer() {
 59 |     return {
 60 |       ready: true,
 61 |       prepareFrame: this.prepareFrame.bind(this),
 62 |       renderFrame: this.render.bind(this)
 63 |     }
 64 |   }
 65 | 
 66 |   async pushPbfTileData(pbf, tileCoord, extent) {
 67 |     const message = {
 68 |       type: PBF_DATA,
 69 |       payload: {
 70 |         data: pbf,
 71 |         tileCoord,
 72 |         extent
 73 |       }
 74 |     }
 75 |     if (this.ready) {
 76 |       this.worker.postMessage(message, [pbf])
 77 |       return Promise.resolve()
 78 |     }
 79 |     return new Promise((resolve, reject) => {
 80 |       try {
 81 |         this.queue.push(() => {
 82 |           this.worker.postMessage(message, [pbf])
 83 |           resolve()
 84 |         })
 85 |       } catch (e) {
 86 |         reject(e)
 87 |       }
 88 |     })
 89 |   }
 90 | 
 91 |   loadTiles(frameState) {
 92 |     const viewState = frameState.viewState
 93 |     const projection = viewState.projection
 94 |     const pixelRatio = frameState.pixelRatio
 95 |     const viewResolution = viewState.resolution
 96 |     const tileQueue = frameState.tileQueue
 97 | 
 98 |     const tileSource = this.getSource()
 99 |     const tileGrid = tileSource.getTileGridForProjection(projection)
100 |     const z = tileGrid.getZForResolution(viewResolution, tileSource.zDirection)
101 | 
102 |     const tileRange = tileGrid.getTileRangeForExtentAndZ(frameState.extent, z)
103 | 
104 |     const tileSourceKey = getUid(tileSource)
105 |     if (!(tileSourceKey in frameState.wantedTiles)) {
106 |       frameState.wantedTiles[tileSourceKey] = {}
107 |     }
108 |     const wantedTiles = frameState.wantedTiles[tileSourceKey]
109 | 
110 |     const tileResolution = tileGrid.getResolution(z)
111 | 
112 |     for (let x = tileRange.minX; x <= tileRange.maxX; ++x) {
113 |       for (let y = tileRange.minY; y <= tileRange.maxY; ++y) {
114 |         const tile = tileSource.getTile(z, x, y, pixelRatio, projection)
115 |         if (tile.getState() == TileState.IDLE) {
116 |           wantedTiles[tile.getKey()] = true
117 |           if (!tileQueue.isKeyQueued(tile.getKey())) {
118 |             tileQueue.enqueue([
119 |               tile,
120 |               tileSourceKey,
121 |               tileGrid.getTileCoordCenter(tile.tileCoord),
122 |               tileResolution,
123 |             ])
124 |           }
125 |         }
126 |       }
127 |     }
128 |   }
129 | 
130 |   setFrameState({ size, viewState: { center, resolution, rotation } }) {
131 |     const slice = new Uint32Array(this.shared_state)
132 | 
133 |     const buffer = new ArrayBuffer(this.shared_state.byteLength)
134 |     const f32_buffer = new Float32Array(buffer)
135 |     const uint32_buffer = new Uint32Array(buffer)
136 | 
137 |     uint32_buffer[0] = size[0]
138 |     uint32_buffer[1] = size[1]
139 | 
140 |     f32_buffer[2] = center[0]
141 |     f32_buffer[3] = center[1]
142 |     f32_buffer[4] = resolution
143 |     f32_buffer[5] = rotation
144 | 
145 |     for (let i = 0; i < uint32_buffer.length; i++) {
146 |       Atomics.store(slice, i, uint32_buffer[i])
147 |     }
148 | 
149 |     Atomics.notify(new Int32Array(this.shared_state), 6, 1)
150 |   }
151 | 
152 |   renderDeferred(frameState) {
153 |     // empty
154 |   }
155 | 
156 |   prepareFrame(frameState) {
157 |     return this.ready
158 |   }
159 | 
160 |   render(frameState) {
161 |     if (!this.container_) {
162 |       this.container_ = this.createContainer()
163 |     }
164 | 
165 |     this.loadTiles(frameState)
166 |     this.setFrameState(frameState)
167 | 
168 |     frameState.animate = !this.ready // TODO: track pbf data fully loaded
169 |     return this.container_
170 |   }
171 | }
172 | 


--------------------------------------------------------------------------------
/src/ressource/tile/mod.rs:
--------------------------------------------------------------------------------
  1 | use std::{marker::ConstParamTy, mem::size_of, num::NonZeroU64, sync::Arc};
  2 | 
  3 | use log::info;
  4 | use mvt_reader::feature::Feature;
  5 | 
  6 | use super::{BindGroupScope, RessourceManager, material::Material, view::View};
  7 | 
  8 | mod fill;
  9 | mod line;
 10 | mod point;
 11 | 
 12 | const DIMENSIONS: usize = 2;
 13 | 
 14 | const TILE_SIZE: f32 = 4096.0;
 15 | 
 16 | #[derive(PartialEq, Eq, Clone, ConstParamTy)]
 17 | pub enum BucketType {
 18 |   Fill,
 19 |   Line,
 20 |   Point,
 21 | }
 22 | 
 23 | #[repr(C)]
 24 | #[derive(Default, Copy, Clone, bytemuck_derive::Pod, bytemuck_derive::Zeroable)]
 25 | struct TileUniform {
 26 |   model_view_matrix: glam::Mat4,
 27 |   clipping_rect: [f32; 4],
 28 | }
 29 | 
 30 | pub struct TileManager;
 31 | 
 32 | pub struct Tile {
 33 |   material: Arc<Material>,
 34 | 
 35 |   bind_group: wgpu::BindGroup,
 36 | 
 37 |   tile_uniform_buffer: wgpu::Buffer,
 38 | 
 39 |   /// vertex buffer
 40 |   vertex_wgpu_buffer: Option<wgpu::Buffer>,
 41 | 
 42 |   vertex_buffer: Vec<f32>,
 43 | 
 44 |   /// index buffer
 45 |   index_wgpu_buffer: Option<wgpu::Buffer>,
 46 | 
 47 |   index_buffer: Vec<u32>,
 48 | 
 49 |   instance_wgpu_buffer: Option<wgpu::Buffer>,
 50 | 
 51 |   extent: [f32; 4],
 52 | 
 53 |   bucket_type: BucketType,
 54 | }
 55 | 
 56 | impl Tile {
 57 |   pub fn add_buffers(&mut self, vertices_buffer: wgpu::Buffer, indices_buffer: wgpu::Buffer) {
 58 |     self.vertex_wgpu_buffer = Some(vertices_buffer);
 59 |     self.index_wgpu_buffer = Some(indices_buffer);
 60 |   }
 61 | 
 62 |   pub fn render<'frame>(
 63 |     &'frame self,
 64 |     render_pass: &mut wgpu::RenderPass<'frame>,
 65 |     queue: &wgpu::Queue,
 66 |     view: &'frame View,
 67 |   ) {
 68 |     match (
 69 |       self.vertex_wgpu_buffer.as_ref(),
 70 |       self.index_wgpu_buffer.as_ref(),
 71 |     ) {
 72 |       (Some(vertex_buffer), Some(index_buffer)) => {
 73 |         self.material.set(render_pass);
 74 |         render_pass.set_bind_group(BindGroupScope::Model as u32, Some(&self.bind_group), &[]);
 75 | 
 76 |         let (half_width, half_height) = view.get_half_size();
 77 |         let tile_uniform =
 78 |           get_transforms(view.get_view_matrix(), self.extent, half_width, half_height);
 79 | 
 80 |         queue.write_buffer(
 81 |           &self.tile_uniform_buffer,
 82 |           0,
 83 |           bytemuck::cast_slice(&[tile_uniform]),
 84 |         );
 85 | 
 86 |         render_pass.set_vertex_buffer(0, vertex_buffer.slice(..));
 87 |         render_pass.set_index_buffer(index_buffer.slice(..), wgpu::IndexFormat::Uint32);
 88 | 
 89 |         let end = index_buffer.size() as u32 / std::mem::size_of::<u32>() as u32;
 90 | 
 91 |         match self.get_bucket_type() {
 92 |           BucketType::Point => {
 93 |             render_pass.set_vertex_buffer(1, self.instance_wgpu_buffer.as_ref().unwrap().slice(..));
 94 |             let instance_end = (self.vertex_buffer.len() / DIMENSIONS) as _;
 95 |             render_pass.draw_indexed(0..end, 0, 0..instance_end);
 96 |           }
 97 |           _ => {
 98 |             render_pass.draw_indexed(0..end, 0, 0..1);
 99 |           }
100 |         }
101 |       }
102 |       _ => {
103 |         info!("No features found")
104 |       }
105 |     }
106 |   }
107 | 
108 |   pub fn get_bucket_type(&self) -> BucketType {
109 |     self.bucket_type.clone()
110 |   }
111 | }
112 | 
113 | /// tile_transform * flip_tile_transform because of Y-axis swap
114 | #[rustfmt::skip]
115 | fn get_model_matrix(extent: [f32; 4], tile_size: f32) -> glam::Mat4 {
116 |   let tile_transform = glam::Mat4::from_cols_array(&[
117 |     (extent[2] - extent[0]) / tile_size, 0.0, 0.0, 0.0, // a11 a21 a31 a41
118 |     0.0, (extent[2] - extent[0]) / tile_size, 0.0, 0.0, // a12 a22 a32 a42
119 |     0.0, 0.0, 1.0, 0.0,                                 // a13 a23 a33 a43
120 |     extent[0], extent[1], 0.0, 1.0,                     // a14 a24 a34 a44
121 |   ]);
122 |   let flip_tile_transform = glam::Mat4::from_cols_array(&[
123 |     1.0, 0.0, 0.0, 0.0,
124 |     0.0, -1.0, 0.0, 0.0,
125 |     0.0, 0.0, 1.0, 0.0,
126 |     0.0, tile_size, 0.0, 1.0,
127 |   ]);
128 |   tile_transform.mul_mat4(&flip_tile_transform)
129 | }
130 | 
131 | fn get_transforms(
132 |   view_matrix: glam::Mat4,
133 |   extent: [f32; 4],
134 |   half_width: f32,
135 |   half_height: f32,
136 | ) -> TileUniform {
137 |   let model_matrix = get_model_matrix(extent, TILE_SIZE);
138 |   let model_view_matrix = view_matrix.mul_mat4(&model_matrix);
139 | 
140 |   let min_extent = model_view_matrix.mul_vec4(glam::Vec4::W);
141 |   let max_extent =
142 |     model_view_matrix.mul_vec4(glam::Vec4::from_slice(&[TILE_SIZE, TILE_SIZE, 0.0, 1.0]));
143 | 
144 |   // convert from view to screen coordinates (pixels)
145 |   let clipping_rect = [
146 |     (min_extent[0] + 1.0) * half_width,
147 |     (-min_extent[1] + 1.0) * half_height,
148 |     (max_extent[0] + 1.0) * half_width,
149 |     (-max_extent[1] + 1.0) * half_height,
150 |   ];
151 | 
152 |   TileUniform {
153 |     model_view_matrix,
154 |     clipping_rect,
155 |   }
156 | }
157 | 
158 | pub trait Bucket<F, const T: BucketType>
159 | where
160 |   Self: Sized,
161 | {
162 |   fn new(ressource_manager: &RessourceManager, extent: [f32; 4]) -> Self;
163 | 
164 |   fn add_features(&mut self, features: &mut Vec<Feature>, ressource_manager: &RessourceManager);
165 | }
166 | 
167 | impl TileManager {
168 |   pub fn new(ressource_manager: &mut RessourceManager) -> Self {
169 |     ressource_manager.register_bind_group_layout(
170 |       BindGroupScope::Model,
171 |       &wgpu::BindGroupLayoutDescriptor {
172 |         label: None,
173 |         entries: &[wgpu::BindGroupLayoutEntry {
174 |           binding: 0,
175 |           visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
176 |           ty: wgpu::BindingType::Buffer {
177 |             ty: wgpu::BufferBindingType::Uniform,
178 |             has_dynamic_offset: false,
179 |             min_binding_size: Some(
180 |               NonZeroU64::new(size_of::<TileUniform>().try_into().unwrap()).unwrap(),
181 |             ),
182 |           },
183 |           count: None,
184 |         }],
185 |       },
186 |     );
187 | 
188 |     Self
189 |   }
190 | }
191 | 


--------------------------------------------------------------------------------
/src/renderer.rs:
--------------------------------------------------------------------------------
  1 | use log::info;
  2 | 
  3 | use crate::{
  4 |   ressource::{
  5 |     RessourceManager,
  6 |     tile::{BucketType, Tile},
  7 |     view::View,
  8 |   },
  9 |   tessellation::LineTessellation,
 10 | };
 11 | 
 12 | const PREFERRED_TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8Unorm;
 13 | const PREFERRED_ALPHA_MODE: wgpu::CompositeAlphaMode = wgpu::CompositeAlphaMode::PreMultiplied;
 14 | 
 15 | pub struct Renderer {
 16 |   /// wgpu device queue pair
 17 |   pub device_queue: (wgpu::Device, wgpu::Queue),
 18 | 
 19 |   /// preferred texutre format of surface
 20 |   pub texture_format: wgpu::TextureFormat,
 21 | 
 22 |   /// used view
 23 |   pub view: View,
 24 | 
 25 |   /// line tessellation
 26 |   line_tessellation: LineTessellation,
 27 | 
 28 |   /// wgpu surface
 29 |   swapchain: wgpu::Surface<'static>,
 30 | 
 31 |   /// wgpu surfaceconfiguration
 32 |   swapchain_config: wgpu::SurfaceConfiguration,
 33 | 
 34 |   pub ressource_manager: RessourceManager,
 35 | }
 36 | 
 37 | pub trait ToSurface {
 38 |   fn create_surface(
 39 |     &self,
 40 |     instance: &wgpu::Instance,
 41 |   ) -> Result<wgpu::Surface<'static>, wgpu::CreateSurfaceError>;
 42 | }
 43 | 
 44 | impl Renderer {
 45 |   pub async fn new<W: ToSurface>(window: &W, (width, height): (u32, u32)) -> Self {
 46 |     let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
 47 |       backends: wgpu::Backends::from_env().unwrap_or(wgpu::Backends::all()),
 48 |       ..Default::default()
 49 |     });
 50 | 
 51 |     let swapchain = match window.create_surface(&instance) {
 52 |       Ok(surface) => surface,
 53 |       Err(err) => {
 54 |         panic!("{}", err.to_string())
 55 |       }
 56 |     };
 57 | 
 58 |     info!("surface: {:?}", &swapchain);
 59 | 
 60 |     let adapter = instance
 61 |       .request_adapter(&wgpu::RequestAdapterOptions {
 62 |         power_preference: wgpu::PowerPreference::from_env()
 63 |           .unwrap_or(wgpu::PowerPreference::HighPerformance),
 64 |         force_fallback_adapter: false,
 65 |         compatible_surface: Some(&swapchain),
 66 |       })
 67 |       .await
 68 |       .expect("Adapter not created.");
 69 | 
 70 |     info!("adapter: {:?}", &adapter);
 71 | 
 72 |     let (device, queue) = adapter
 73 |       .request_device(&wgpu::DeviceDescriptor::default())
 74 |       .await
 75 |       .expect("Device can't be created.");
 76 | 
 77 |     info!("device: {:?}", device);
 78 | 
 79 |     let swapchain_capabilities = swapchain.get_capabilities(&adapter);
 80 | 
 81 |     info!(
 82 |       "supported surface formats: {:?}",
 83 |       swapchain_capabilities.formats
 84 |     );
 85 | 
 86 |     let texture_format = if swapchain_capabilities
 87 |       .formats
 88 |       .contains(&PREFERRED_TEXTURE_FORMAT)
 89 |     {
 90 |       PREFERRED_TEXTURE_FORMAT
 91 |     } else {
 92 |       swapchain_capabilities
 93 |         .formats
 94 |         .first()
 95 |         .expect("Can't get texture format for surface.")
 96 |         .to_owned()
 97 |     };
 98 | 
 99 |     info!(
100 |       "supported alpha modes: {:?}",
101 |       swapchain_capabilities.alpha_modes
102 |     );
103 | 
104 |     let alpha_mode = if swapchain_capabilities
105 |       .alpha_modes
106 |       .contains(&PREFERRED_ALPHA_MODE)
107 |     {
108 |       PREFERRED_ALPHA_MODE
109 |     } else {
110 |       swapchain_capabilities
111 |         .alpha_modes
112 |         .first()
113 |         .expect("Can't get present mode for surface.")
114 |         .to_owned()
115 |     };
116 | 
117 |     let swapchain_config = wgpu::SurfaceConfiguration {
118 |       usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
119 |       format: texture_format,
120 |       width,
121 |       height,
122 |       desired_maximum_frame_latency: 2,
123 |       present_mode: wgpu::PresentMode::Fifo,
124 |       alpha_mode,
125 |       view_formats: vec![],
126 |     };
127 | 
128 |     swapchain.configure(&device, &swapchain_config);
129 | 
130 |     let line_tessellation = LineTessellation::new((device.clone(), queue.clone()));
131 | 
132 |     let mut ressource_manager = RessourceManager::new(device.clone(), texture_format);
133 | 
134 |     Self {
135 |       device_queue: (device, queue),
136 |       texture_format,
137 |       view: View::new((width, height), &mut ressource_manager),
138 |       line_tessellation,
139 |       swapchain,
140 |       swapchain_config,
141 |       ressource_manager,
142 |     }
143 |   }
144 | 
145 |   pub fn create_tile<F>(&self, bucket_type: BucketType, extent: [f32; 4]) -> Tile {
146 |     self.ressource_manager.create_tile::<F>(bucket_type, extent)
147 |   }
148 | 
149 |   pub fn set_size(&mut self, (width, height): (u32, u32)) {
150 |     let (device, _) = &self.device_queue;
151 | 
152 |     self.swapchain_config.width = width;
153 |     self.swapchain_config.height = height;
154 |     self.swapchain.configure(device, &self.swapchain_config);
155 |     self.view.set_size((width, height));
156 |   }
157 | 
158 |   pub async fn compute(
159 |     &mut self,
160 |     vertices: &[f32],
161 |     indices: &[u32],
162 |   ) -> (wgpu::Buffer, wgpu::Buffer) {
163 |     self.line_tessellation.tessellate((vertices, indices)).await
164 |   }
165 | 
166 |   pub fn render(&self, tiles: &[Tile]) {
167 |     let (device, queue) = &self.device_queue;
168 |     let mut command_encoder =
169 |       device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
170 | 
171 |     let surface_texture = self
172 |       .swapchain
173 |       .get_current_texture()
174 |       .expect("Can't get current texture");
175 | 
176 |     let view = surface_texture
177 |       .texture
178 |       .create_view(&wgpu::TextureViewDescriptor::default());
179 | 
180 |     {
181 |       command_encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
182 |         label: None,
183 |         color_attachments: &[Some(wgpu::RenderPassColorAttachment {
184 |           view: &view,
185 |           resolve_target: None,
186 |           ops: wgpu::Operations {
187 |             load: wgpu::LoadOp::Clear(wgpu::Color {
188 |               r: 0.0,
189 |               g: 0.412,
190 |               b: 0.58,
191 |               a: 1.0,
192 |             }),
193 |             store: wgpu::StoreOp::Store,
194 |           },
195 |         })],
196 |         ..Default::default()
197 |       });
198 |     } // out of scope
199 | 
200 |     {
201 |       let mut render_pass = command_encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
202 |         label: None,
203 |         color_attachments: &[Some(wgpu::RenderPassColorAttachment {
204 |           view: &view,
205 |           resolve_target: None,
206 |           ops: wgpu::Operations {
207 |             load: wgpu::LoadOp::Load,
208 |             store: wgpu::StoreOp::Store,
209 |           },
210 |         })],
211 |         ..Default::default()
212 |       });
213 | 
214 |       self.view.set(&mut render_pass, queue);
215 | 
216 |       // FIXME: set material / shader here. group by material in bucket
217 |       for tile in tiles.iter() {
218 |         tile.render(&mut render_pass, queue, &self.view);
219 |       }
220 |     }
221 | 
222 |     queue.submit(Some(command_encoder.finish()));
223 |     surface_texture.present();
224 |   }
225 | }
226 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
  1 | #![allow(incomplete_features)]
  2 | #![feature(adt_const_params)]
  3 | 
  4 | use log::error;
  5 | use mvt_reader::feature::Feature;
  6 | use ressource::tile::{Bucket, BucketType, Tile};
  7 | use std::cell::{Cell, RefCell};
  8 | use std::rc::Rc;
  9 | use std::sync::mpsc::TryRecvError::{Disconnected, Empty};
 10 | use std::sync::mpsc::{Receiver, Sender, channel};
 11 | 
 12 | #[cfg(target_arch = "wasm32")]
 13 | use wasm_bindgen::prelude::*;
 14 | 
 15 | use geo_types::Geometry::{LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon};
 16 | 
 17 | pub mod renderer;
 18 | mod ressource;
 19 | mod tessellation;
 20 | 
 21 | #[derive(Default)]
 22 | pub struct Instance {
 23 |   renderer: Rc<RefCell<Option<renderer::Renderer>>>,
 24 |   tiles: Rc<RefCell<Vec<Tile>>>,
 25 |   current_size: Cell<(u32, u32)>,
 26 | }
 27 | 
 28 | struct Message {
 29 |   parsed_features: Vec<Feature>,
 30 |   extent: Vec<f32>,
 31 | }
 32 | 
 33 | thread_local! {
 34 |   static TILE_PARSER_QUEUE: (Sender<Message>, Receiver<Message>) = channel();
 35 |   static INSTANCE: Instance = Instance::default();
 36 | }
 37 | 
 38 | #[cfg(target_arch = "wasm32")]
 39 | const DIMENSIONS: usize = 2;
 40 | 
 41 | #[cfg(target_arch = "wasm32")]
 42 | pub mod wasm {
 43 |   use wasm_bindgen::prelude::*;
 44 | 
 45 |   pub use wasm_bindgen_rayon::init_thread_pool;
 46 | 
 47 |   impl super::renderer::ToSurface for web_sys::OffscreenCanvas {
 48 |     fn create_surface(
 49 |       &self,
 50 |       instance: &wgpu::Instance,
 51 |     ) -> Result<wgpu::Surface<'static>, wgpu::CreateSurfaceError> {
 52 |       instance.create_surface(wgpu::SurfaceTarget::OffscreenCanvas(self.clone()))
 53 |     }
 54 |   }
 55 | 
 56 |   impl super::renderer::ToSurface for web_sys::HtmlCanvasElement {
 57 |     fn create_surface(
 58 |       &self,
 59 |       instance: &wgpu::Instance,
 60 |     ) -> Result<wgpu::Surface<'static>, wgpu::CreateSurfaceError> {
 61 |       instance.create_surface(wgpu::SurfaceTarget::Canvas(self.clone()))
 62 |     }
 63 |   }
 64 | 
 65 |   #[wasm_bindgen(js_name = startWithOffscreenCanvas)]
 66 |   pub async fn start_with_offscreencanvas(canvas: &web_sys::OffscreenCanvas) {
 67 |     #[cfg(feature = "console_error_panic_hook")]
 68 |     console_error_panic_hook::set_once();
 69 | 
 70 |     #[cfg(feature = "console_log")]
 71 |     match console_log::init_with_level(log::Level::Info) {
 72 |       Ok(()) => (),
 73 |       Err(err) => log::error!("{}", err),
 74 |     }
 75 | 
 76 |     super::init(canvas, (canvas.width(), canvas.height())).await;
 77 |   }
 78 | 
 79 |   #[wasm_bindgen(js_name = startWithCanvas)]
 80 |   pub async fn start_with_canvas(canvas: &web_sys::HtmlCanvasElement) {
 81 |     #[cfg(feature = "console_error_panic_hook")]
 82 |     console_error_panic_hook::set_once();
 83 | 
 84 |     #[cfg(feature = "console_log")]
 85 |     match console_log::init_with_level(log::Level::Info) {
 86 |       Ok(()) => (),
 87 |       Err(err) => log::error!("{}", err),
 88 |     }
 89 | 
 90 |     super::init(canvas, (canvas.width(), canvas.height())).await;
 91 |   }
 92 | }
 93 | 
 94 | #[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
 95 | pub fn render(view_matrix: Vec<f32>, new_size: Vec<u32>) {
 96 |   process_tile_parser_queue();
 97 | 
 98 |   INSTANCE.with(|instance| {
 99 |     let mut reference = instance.renderer.borrow_mut();
100 |     let renderer = reference.as_mut().unwrap();
101 | 
102 |     renderer
103 |       .view
104 |       .set_view_matrix(glam::Mat4::from_cols_slice(&view_matrix[..]));
105 | 
106 |     let current_size = instance.current_size.get();
107 |     if current_size.0 != new_size[0] || current_size.1 != new_size[1] {
108 |       instance.current_size.set((new_size[0], new_size[1]));
109 |       renderer.set_size(instance.current_size.get());
110 |     }
111 | 
112 |     renderer.render(&instance.tiles.borrow());
113 |   });
114 | }
115 | 
116 | #[cfg(target_arch = "wasm32")]
117 | fn get_buffers(features: &[Feature]) -> (Vec<f32>, Vec<u32>) {
118 |   let mut all_vertices = vec![];
119 |   let mut all_indices = vec![];
120 | 
121 |   for feature in features.iter() {
122 |     match feature.get_geometry() {
123 |       LineString(line) => {
124 |         let mut vertices = Vec::with_capacity(line.0.len() * DIMENSIONS);
125 |         let mut indices = Vec::with_capacity(line.0.len());
126 |         let offset = (all_vertices.len() / DIMENSIONS) as u32;
127 | 
128 |         for (i, coord) in line.0.iter().enumerate() {
129 |           vertices.push(coord.x);
130 |           vertices.push(coord.y);
131 |           indices.push(i as u32 + offset);
132 |         }
133 | 
134 |         if let Some(last) = indices.last() {
135 |           indices.push(*last); // separate linestring from the next one
136 |         }
137 | 
138 |         all_vertices.append(&mut vertices);
139 |         all_indices.append(&mut indices);
140 |       }
141 |       MultiLineString(multi_line) => {
142 |         for line in multi_line.0.iter() {
143 |           let mut vertices = Vec::with_capacity(line.0.len() * DIMENSIONS);
144 |           let mut indices = Vec::with_capacity(line.0.len());
145 |           let offset = (all_vertices.len() / DIMENSIONS) as u32;
146 |           for (i, coord) in line.0.iter().enumerate() {
147 |             vertices.push(coord.x);
148 |             vertices.push(coord.y);
149 |             indices.push(i as u32 + offset);
150 |           }
151 | 
152 |           if let Some(last) = indices.last() {
153 |             indices.push(*last); // separate linestring from the next one
154 |           }
155 | 
156 |           all_vertices.append(&mut vertices);
157 |           all_indices.append(&mut indices);
158 |         }
159 |       }
160 |       _ => {
161 |         log::info!("Geometry type currently not supported");
162 |       }
163 |     }
164 |   }
165 |   (all_vertices, all_indices)
166 | }
167 | 
168 | fn process_tile_parser_queue() {
169 |   TILE_PARSER_QUEUE.with(|(_, receiver)| {
170 |     loop {
171 |       match receiver.try_recv() {
172 |         Ok(msg) => {
173 |           let mut parsed_features = msg.parsed_features;
174 |           if parsed_features.is_empty() {
175 |             return;
176 |           }
177 | 
178 |           INSTANCE.with(|instance| {
179 |             let extent: [f32; 4] = msg.extent.try_into().unwrap();
180 |             let mut reference = instance.renderer.try_borrow_mut().unwrap();
181 |             let renderer = reference.as_mut().unwrap();
182 | 
183 |             if let Some(feature) = parsed_features.first() {
184 |               match feature.get_geometry() {
185 |                 &Point(_) | &MultiPoint(_) => {
186 |                   let mut tile = renderer.create_tile::<Feature>(BucketType::Point, extent);
187 | 
188 |                   if tile.get_bucket_type() == BucketType::Point {
189 |                     <Tile as Bucket<Feature, { BucketType::Point }>>::add_features(
190 |                       &mut tile,
191 |                       &mut parsed_features,
192 |                       &renderer.ressource_manager,
193 |                     );
194 |                   }
195 | 
196 |                   instance.tiles.borrow_mut().push(tile);
197 |                 }
198 |                 &LineString(_) | &MultiLineString(_) => {
199 |                   #[cfg(target_arch = "wasm32")]
200 |                   {
201 |                     let (vertices, indices) = get_buffers(&parsed_features[..]);
202 | 
203 |                     let clone = instance.renderer.clone();
204 |                     let tiles = instance.tiles.clone();
205 | 
206 |                     #[allow(clippy::await_holding_refcell_ref)]
207 |                     wasm_bindgen_futures::spawn_local(async move {
208 |                       let mut reference = clone.borrow_mut();
209 |                       let renderer = reference.as_mut().unwrap();
210 |                       let (vertices_buffer, indices_buffer) =
211 |                         renderer.compute(&vertices[..], &indices[..]).await;
212 | 
213 |                       let mut tile = renderer.create_tile::<Feature>(BucketType::Line, extent);
214 |                       tile.add_buffers(vertices_buffer, indices_buffer);
215 |                       tiles.borrow_mut().push(tile);
216 |                     });
217 |                   }
218 |                 }
219 |                 &Polygon(_) | &MultiPolygon(_) => {
220 |                   let mut tile = renderer.create_tile::<Feature>(BucketType::Fill, extent);
221 | 
222 |                   if tile.get_bucket_type() == BucketType::Fill {
223 |                     <Tile as Bucket<Feature, { BucketType::Fill }>>::add_features(
224 |                       &mut tile,
225 |                       &mut parsed_features,
226 |                       &renderer.ressource_manager,
227 |                     );
228 |                   }
229 | 
230 |                   instance.tiles.borrow_mut().push(tile);
231 |                 }
232 |                 _ => (),
233 |               }
234 |             }
235 |           });
236 |         }
237 |         Err(err) => match err {
238 |           Disconnected => {
239 |             error!("{}", err);
240 |             break;
241 |           }
242 |           Empty => {
243 |             break;
244 |           }
245 |         },
246 |       }
247 |     }
248 |   });
249 | }
250 | 
251 | #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = addPbfTileData))]
252 | pub async fn add_pbf_tile_data(pbf: Vec<u8>, _tile_coord: Vec<u32>, extent: Vec<f32>) {
253 |   TILE_PARSER_QUEUE.with(|(sender, _)| {
254 |     let sender = sender.clone();
255 | 
256 |     let parse = move || {
257 |       let reader = mvt_reader::Reader::new(pbf).expect("parse error");
258 |       let layer_names = reader.get_layer_names().unwrap();
259 | 
260 |       for (i, _) in layer_names.iter().enumerate() {
261 |         sender
262 |           .send(Message {
263 |             parsed_features: reader.get_features(i).unwrap(),
264 |             extent: extent.clone(),
265 |           })
266 |           .unwrap();
267 |       }
268 |     };
269 | 
270 |     #[cfg(not(feature = "multithreaded"))]
271 |     parse();
272 | 
273 |     #[cfg(feature = "multithreaded")]
274 |     rayon::spawn(parse);
275 |   });
276 | }
277 | 
278 | pub async fn init<W: renderer::ToSurface>(window: &W, size: (u32, u32)) {
279 |   let renderer = renderer::Renderer::new(window, size).await;
280 | 
281 |   INSTANCE.with(|instance| {
282 |     instance.renderer.replace(Some(renderer));
283 |     instance.tiles.replace(Vec::new());
284 |     instance.current_size.replace(size);
285 |   });
286 | }
287 | 


--------------------------------------------------------------------------------
/src/tessellation/mod.rs:
--------------------------------------------------------------------------------
  1 | use wgpu::util::DeviceExt;
  2 | 
  3 | static WORK_GROUP_MAX_X: f32 = 256.0;
  4 | 
  5 | #[repr(C)]
  6 | #[derive(Copy, Clone, bytemuck_derive::Pod, bytemuck_derive::Zeroable)]
  7 | struct OutputVertex {
  8 |   position: [f32; 2],
  9 |   normal: [f32; 2],
 10 | }
 11 | 
 12 | pub struct LineTessellation {
 13 |   /// wgpu device and queue pair
 14 |   device_queue: (wgpu::Device, wgpu::Queue),
 15 | 
 16 |   /// wgpu pipeline
 17 |   pipeline: wgpu::ComputePipeline,
 18 | 
 19 |   /// bind group layout
 20 |   bind_group_layout: wgpu::BindGroupLayout,
 21 | }
 22 | 
 23 | impl LineTessellation {
 24 |   pub fn new((device, queue): (wgpu::Device, wgpu::Queue)) -> Self {
 25 |     let shader_module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
 26 |       label: None,
 27 |       source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(include_str!(
 28 |         "shader/line.wgsl"
 29 |       ))),
 30 |     });
 31 | 
 32 |     let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
 33 |       label: None,
 34 |       entries: &[
 35 |         wgpu::BindGroupLayoutEntry {
 36 |           binding: 0,
 37 |           visibility: wgpu::ShaderStages::COMPUTE,
 38 |           ty: wgpu::BindingType::Buffer {
 39 |             ty: wgpu::BufferBindingType::Storage { read_only: true },
 40 |             has_dynamic_offset: false,
 41 |             min_binding_size: None,
 42 |           },
 43 |           count: None,
 44 |         },
 45 |         wgpu::BindGroupLayoutEntry {
 46 |           binding: 1,
 47 |           visibility: wgpu::ShaderStages::COMPUTE,
 48 |           ty: wgpu::BindingType::Buffer {
 49 |             ty: wgpu::BufferBindingType::Storage { read_only: true },
 50 |             has_dynamic_offset: false,
 51 |             min_binding_size: None,
 52 |           },
 53 |           count: None,
 54 |         },
 55 |         wgpu::BindGroupLayoutEntry {
 56 |           binding: 2,
 57 |           visibility: wgpu::ShaderStages::COMPUTE,
 58 |           ty: wgpu::BindingType::Buffer {
 59 |             ty: wgpu::BufferBindingType::Storage { read_only: false },
 60 |             has_dynamic_offset: false,
 61 |             min_binding_size: None,
 62 |           },
 63 |           count: None,
 64 |         },
 65 |         wgpu::BindGroupLayoutEntry {
 66 |           binding: 3,
 67 |           visibility: wgpu::ShaderStages::COMPUTE,
 68 |           ty: wgpu::BindingType::Buffer {
 69 |             ty: wgpu::BufferBindingType::Storage { read_only: false },
 70 |             has_dynamic_offset: false,
 71 |             min_binding_size: None,
 72 |           },
 73 |           count: None,
 74 |         },
 75 |       ],
 76 |     });
 77 | 
 78 |     let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
 79 |       label: None,
 80 |       bind_group_layouts: &[&bind_group_layout],
 81 |       push_constant_ranges: &[],
 82 |     });
 83 | 
 84 |     let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
 85 |       label: None,
 86 |       layout: Some(&pipeline_layout),
 87 |       entry_point: Some("main"),
 88 |       module: &shader_module,
 89 |       compilation_options: wgpu::PipelineCompilationOptions::default(),
 90 |       cache: None,
 91 |     });
 92 | 
 93 |     Self {
 94 |       device_queue: (device, queue),
 95 |       pipeline,
 96 |       bind_group_layout,
 97 |     }
 98 |   }
 99 | 
100 |   fn create_buffers(&self, vertices: &[f32], indices: &[u32]) -> [wgpu::Buffer; 4] {
101 |     let (device, _) = &self.device_queue;
102 | 
103 |     // generate 4 vertices for each edge and 6 indices for each edge
104 |     let line_vertices_buffer_size =
105 |       (std::mem::size_of::<OutputVertex>() * (indices.len()) * 4) as u64;
106 |     let line_indices_buffer_size = (std::mem::size_of_val(indices) * 6) as u64;
107 | 
108 |     [
109 |       device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
110 |         label: None,
111 |         contents: bytemuck::cast_slice(vertices),
112 |         usage: wgpu::BufferUsages::STORAGE, // for the compute shader
113 |       }),
114 |       device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
115 |         label: None,
116 |         contents: bytemuck::cast_slice(indices),
117 |         usage: wgpu::BufferUsages::STORAGE, // for the compute shader
118 |       }),
119 |       device.create_buffer(&wgpu::BufferDescriptor {
120 |         label: None,
121 |         usage: wgpu::BufferUsages::VERTEX // reuse as vertex buffer later
122 |           | wgpu::BufferUsages::STORAGE // for the compute shader
123 |           | wgpu::BufferUsages::COPY_SRC, // for debug and test purposes
124 |         size: line_vertices_buffer_size,
125 |         mapped_at_creation: false,
126 |       }),
127 |       device.create_buffer(&wgpu::BufferDescriptor {
128 |         label: None,
129 |         usage: wgpu::BufferUsages::INDEX // reuse as index buffer later
130 |           | wgpu::BufferUsages::STORAGE // for the compute shader
131 |           | wgpu::BufferUsages::COPY_SRC, // for debug and test purposes
132 |         size: line_indices_buffer_size,
133 |         mapped_at_creation: false,
134 |       }),
135 |     ]
136 |   }
137 | 
138 |   fn create_bind_group(
139 |     &self,
140 |     vertices_buffer: &wgpu::Buffer,
141 |     indices_buffer: &wgpu::Buffer,
142 |     line_vertices_buffer: &wgpu::Buffer,
143 |     line_indices_buffer: &wgpu::Buffer,
144 |   ) -> wgpu::BindGroup {
145 |     let (device, _) = &self.device_queue;
146 | 
147 |     device.create_bind_group(&wgpu::BindGroupDescriptor {
148 |       label: None,
149 |       layout: &self.bind_group_layout,
150 |       entries: &[
151 |         wgpu::BindGroupEntry {
152 |           binding: 0,
153 |           resource: vertices_buffer.as_entire_binding(),
154 |         },
155 |         wgpu::BindGroupEntry {
156 |           binding: 1,
157 |           resource: indices_buffer.as_entire_binding(),
158 |         },
159 |         wgpu::BindGroupEntry {
160 |           binding: 2,
161 |           resource: line_vertices_buffer.as_entire_binding(),
162 |         },
163 |         wgpu::BindGroupEntry {
164 |           binding: 3,
165 |           resource: line_indices_buffer.as_entire_binding(),
166 |         },
167 |       ],
168 |     })
169 |   }
170 | 
171 |   // TODO: maybe later a variant with VERTEX and INDEX buffer as input params
172 |   pub async fn tessellate(
173 |     &self,
174 |     (vertices, indices): (&[f32], &[u32]),
175 |   ) -> (wgpu::Buffer, wgpu::Buffer) {
176 |     let (device, queue) = &self.device_queue;
177 | 
178 |     #[rustfmt::skip]
179 |     let [
180 |       vertices_buffer,
181 |       indices_buffer,
182 |       line_vertices_buffer,
183 |       line_indices_buffer
184 |     ] = self.create_buffers(vertices, indices);
185 | 
186 |     let bind_group = self.create_bind_group(
187 |       &vertices_buffer,
188 |       &indices_buffer,
189 |       &line_vertices_buffer,
190 |       &line_indices_buffer,
191 |     );
192 | 
193 |     let mut command_encoder =
194 |       device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
195 |     {
196 |       let mut pass = command_encoder.begin_compute_pass(&wgpu::ComputePassDescriptor::default());
197 | 
198 |       pass.set_pipeline(&self.pipeline);
199 |       pass.set_bind_group(0, Some(&bind_group), &[]);
200 | 
201 |       let x = (indices.len() as f32 / WORK_GROUP_MAX_X).ceil() as u32;
202 |       pass.dispatch_workgroups(x, 1, 1);
203 |     } // out of scope
204 | 
205 |     queue.submit(Some(command_encoder.finish()));
206 | 
207 |     (line_vertices_buffer, line_indices_buffer)
208 |   }
209 | }
210 | 
211 | #[cfg(test)]
212 | #[cfg(not(target_arch = "wasm32"))]
213 | mod tests {
214 |   use super::*;
215 |   use log::info;
216 |   use std::sync::Arc;
217 | 
218 |   #[repr(C)]
219 |   #[derive(Debug, Default, Copy, Clone, bytemuck_derive::Pod, bytemuck_derive::Zeroable)]
220 |   struct Vertex {
221 |     position: [f32; 2],
222 |     normal: [f32; 2],
223 |   }
224 | 
225 |   async fn initialize_test() -> (wgpu::Device, wgpu::Queue) {
226 |     env_logger::init_from_env(
227 |       env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
228 |     );
229 | 
230 |     let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
231 |       backends: wgpu::Backends::from_env().unwrap_or(wgpu::Backends::all()),
232 |       ..Default::default()
233 |     });
234 | 
235 |     let adapter = instance
236 |       .request_adapter(&wgpu::RequestAdapterOptions {
237 |         power_preference: wgpu::PowerPreference::HighPerformance,
238 |         force_fallback_adapter: false,
239 |         compatible_surface: None,
240 |       })
241 |       .await
242 |       .unwrap();
243 | 
244 |     adapter
245 |       .request_device(&wgpu::DeviceDescriptor::default())
246 |       .await
247 |       .unwrap()
248 |   }
249 | 
250 |   async fn map_and_log_buffer<F>(
251 |     (device, queue): (wgpu::Device, wgpu::Queue),
252 |     src_buffer: &wgpu::Buffer,
253 |     src_buffer_size: u64,
254 |     from_bytes: F,
255 |   ) where
256 |     F: Fn(&[u8]),
257 |   {
258 |     let dest_buffer = device.create_buffer(&wgpu::BufferDescriptor {
259 |       label: None,
260 |       usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
261 |       size: src_buffer_size,
262 |       mapped_at_creation: false,
263 |     });
264 | 
265 |     let mut command_encoder =
266 |       device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
267 | 
268 |     command_encoder.copy_buffer_to_buffer(src_buffer, 0, &dest_buffer, 0, src_buffer_size);
269 | 
270 |     let submission_index = queue.submit(Some(command_encoder.finish()));
271 | 
272 |     let (sender, receiver) = futures::channel::oneshot::channel();
273 |     let buffer_slice = dest_buffer.slice(..);
274 | 
275 |     buffer_slice.map_async(wgpu::MapMode::Read, move |v| match sender.send(v) {
276 |       Ok(_) => (),
277 |       Err(error) => match error {
278 |         Ok(_) => (),
279 |         Err(error) => {
280 |           panic!("{error:?}")
281 |         }
282 |       },
283 |     });
284 | 
285 |     device
286 |       .poll(wgpu::PollType::WaitForSubmissionIndex(submission_index))
287 |       .unwrap(); // has no effect for web target
288 | 
289 |     match receiver.await {
290 |       Ok(rec_result) => match rec_result {
291 |         Ok(_) => {
292 |           {
293 |             let bytes = buffer_slice.get_mapped_range();
294 |             from_bytes(&bytes[..]);
295 |           } // out of scope
296 |           dest_buffer.unmap();
297 |         }
298 |         Err(error) => panic!("{error:?}"),
299 |       },
300 |       Err(error) => panic!("{error:?}"),
301 |     }
302 |   }
303 | 
304 |   #[test]
305 |   fn compute_lines() {
306 |     let (device, queue) = pollster::block_on(initialize_test());
307 | 
308 |     let vertices = [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0];
309 |     let indices = [0, 1, 2, 3, 0];
310 | 
311 |     let line_tessellation = Arc::new(LineTessellation::new((device.clone(), queue.clone())));
312 | 
313 |     let line_tessellation1 = line_tessellation.clone();
314 |     let device1 = device.clone();
315 |     let queue1 = queue.clone();
316 |     let handle1 = std::thread::spawn(move || {
317 |       let (vertices, indices) =
318 |         pollster::block_on(line_tessellation1.tessellate((&vertices, &indices)));
319 |       {
320 |         pollster::block_on(map_and_log_buffer(
321 |           (device1.clone(), queue1.clone()),
322 |           &vertices,
323 |           vertices.size(),
324 |           |bytes| {
325 |             let size = std::mem::size_of::<Vertex>();
326 |             for i in 0..16 {
327 |               let start = i * size;
328 |               let end = start + size;
329 |               let output: Vertex = *bytemuck::from_bytes(&bytes[start..end]);
330 |               info!("{:?}", output);
331 |             }
332 |           },
333 |         ));
334 |         pollster::block_on(map_and_log_buffer(
335 |           (device1, queue1),
336 |           &indices,
337 |           indices.size(),
338 |           |bytes| {
339 |             let size = std::mem::size_of::<u32>();
340 |             let indices: Vec<u32> = (0..24)
341 |               .enumerate()
342 |               .map(|(i, _)| {
343 |                 let start = i * size;
344 |                 let end = start + size;
345 |                 *bytemuck::from_bytes(&bytes[start..end])
346 |               })
347 |               .collect();
348 |             info!("{:?}", indices);
349 |           },
350 |         ));
351 |       }
352 |     });
353 |     let handle2 = std::thread::spawn(move || {
354 |       let (vertices, indices) =
355 |         pollster::block_on(line_tessellation.tessellate((&vertices, &indices)));
356 |       {
357 |         pollster::block_on(map_and_log_buffer(
358 |           (device.clone(), queue.clone()),
359 |           &vertices,
360 |           vertices.size(),
361 |           |_| {},
362 |         ));
363 |         pollster::block_on(map_and_log_buffer(
364 |           (device, queue),
365 |           &indices,
366 |           indices.size(),
367 |           |_| {},
368 |         ));
369 |       }
370 |     });
371 | 
372 |     handle1.join().unwrap();
373 |     handle2.join().unwrap();
374 |   }
375 | }
376 | 


--------------------------------------------------------------------------------
/demo/package-lock.json:
--------------------------------------------------------------------------------
   1 | {
   2 |   "name": "wgpu-layers-demo",
   3 |   "version": "0.1.0",
   4 |   "lockfileVersion": 3,
   5 |   "requires": true,
   6 |   "packages": {
   7 |     "": {
   8 |       "name": "wgpu-layers-demo",
   9 |       "version": "0.1.0",
  10 |       "license": "MIT",
  11 |       "dependencies": {
  12 |         "ol": "10.6.1",
  13 |         "wgpu-layers": "file:../pkg"
  14 |       },
  15 |       "devDependencies": {
  16 |         "vite": "7.1.11"
  17 |       }
  18 |     },
  19 |     "../pkg": {
  20 |       "name": "wgpu-layers",
  21 |       "version": "0.1.0",
  22 |       "license": "MIT"
  23 |     },
  24 |     "node_modules/@esbuild/aix-ppc64": {
  25 |       "version": "0.25.9",
  26 |       "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.9.tgz",
  27 |       "integrity": "sha512-OaGtL73Jck6pBKjNIe24BnFE6agGl+6KxDtTfHhy1HmhthfKouEcOhqpSL64K4/0WCtbKFLOdzD/44cJ4k9opA==",
  28 |       "cpu": [
  29 |         "ppc64"
  30 |       ],
  31 |       "dev": true,
  32 |       "license": "MIT",
  33 |       "optional": true,
  34 |       "os": [
  35 |         "aix"
  36 |       ],
  37 |       "engines": {
  38 |         "node": ">=18"
  39 |       }
  40 |     },
  41 |     "node_modules/@esbuild/android-arm": {
  42 |       "version": "0.25.9",
  43 |       "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.9.tgz",
  44 |       "integrity": "sha512-5WNI1DaMtxQ7t7B6xa572XMXpHAaI/9Hnhk8lcxF4zVN4xstUgTlvuGDorBguKEnZO70qwEcLpfifMLoxiPqHQ==",
  45 |       "cpu": [
  46 |         "arm"
  47 |       ],
  48 |       "dev": true,
  49 |       "license": "MIT",
  50 |       "optional": true,
  51 |       "os": [
  52 |         "android"
  53 |       ],
  54 |       "engines": {
  55 |         "node": ">=18"
  56 |       }
  57 |     },
  58 |     "node_modules/@esbuild/android-arm64": {
  59 |       "version": "0.25.9",
  60 |       "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.9.tgz",
  61 |       "integrity": "sha512-IDrddSmpSv51ftWslJMvl3Q2ZT98fUSL2/rlUXuVqRXHCs5EUF1/f+jbjF5+NG9UffUDMCiTyh8iec7u8RlTLg==",
  62 |       "cpu": [
  63 |         "arm64"
  64 |       ],
  65 |       "dev": true,
  66 |       "license": "MIT",
  67 |       "optional": true,
  68 |       "os": [
  69 |         "android"
  70 |       ],
  71 |       "engines": {
  72 |         "node": ">=18"
  73 |       }
  74 |     },
  75 |     "node_modules/@esbuild/android-x64": {
  76 |       "version": "0.25.9",
  77 |       "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.9.tgz",
  78 |       "integrity": "sha512-I853iMZ1hWZdNllhVZKm34f4wErd4lMyeV7BLzEExGEIZYsOzqDWDf+y082izYUE8gtJnYHdeDpN/6tUdwvfiw==",
  79 |       "cpu": [
  80 |         "x64"
  81 |       ],
  82 |       "dev": true,
  83 |       "license": "MIT",
  84 |       "optional": true,
  85 |       "os": [
  86 |         "android"
  87 |       ],
  88 |       "engines": {
  89 |         "node": ">=18"
  90 |       }
  91 |     },
  92 |     "node_modules/@esbuild/darwin-arm64": {
  93 |       "version": "0.25.9",
  94 |       "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.9.tgz",
  95 |       "integrity": "sha512-XIpIDMAjOELi/9PB30vEbVMs3GV1v2zkkPnuyRRURbhqjyzIINwj+nbQATh4H9GxUgH1kFsEyQMxwiLFKUS6Rg==",
  96 |       "cpu": [
  97 |         "arm64"
  98 |       ],
  99 |       "dev": true,
 100 |       "license": "MIT",
 101 |       "optional": true,
 102 |       "os": [
 103 |         "darwin"
 104 |       ],
 105 |       "engines": {
 106 |         "node": ">=18"
 107 |       }
 108 |     },
 109 |     "node_modules/@esbuild/darwin-x64": {
 110 |       "version": "0.25.9",
 111 |       "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.9.tgz",
 112 |       "integrity": "sha512-jhHfBzjYTA1IQu8VyrjCX4ApJDnH+ez+IYVEoJHeqJm9VhG9Dh2BYaJritkYK3vMaXrf7Ogr/0MQ8/MeIefsPQ==",
 113 |       "cpu": [
 114 |         "x64"
 115 |       ],
 116 |       "dev": true,
 117 |       "license": "MIT",
 118 |       "optional": true,
 119 |       "os": [
 120 |         "darwin"
 121 |       ],
 122 |       "engines": {
 123 |         "node": ">=18"
 124 |       }
 125 |     },
 126 |     "node_modules/@esbuild/freebsd-arm64": {
 127 |       "version": "0.25.9",
 128 |       "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.9.tgz",
 129 |       "integrity": "sha512-z93DmbnY6fX9+KdD4Ue/H6sYs+bhFQJNCPZsi4XWJoYblUqT06MQUdBCpcSfuiN72AbqeBFu5LVQTjfXDE2A6Q==",
 130 |       "cpu": [
 131 |         "arm64"
 132 |       ],
 133 |       "dev": true,
 134 |       "license": "MIT",
 135 |       "optional": true,
 136 |       "os": [
 137 |         "freebsd"
 138 |       ],
 139 |       "engines": {
 140 |         "node": ">=18"
 141 |       }
 142 |     },
 143 |     "node_modules/@esbuild/freebsd-x64": {
 144 |       "version": "0.25.9",
 145 |       "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.9.tgz",
 146 |       "integrity": "sha512-mrKX6H/vOyo5v71YfXWJxLVxgy1kyt1MQaD8wZJgJfG4gq4DpQGpgTB74e5yBeQdyMTbgxp0YtNj7NuHN0PoZg==",
 147 |       "cpu": [
 148 |         "x64"
 149 |       ],
 150 |       "dev": true,
 151 |       "license": "MIT",
 152 |       "optional": true,
 153 |       "os": [
 154 |         "freebsd"
 155 |       ],
 156 |       "engines": {
 157 |         "node": ">=18"
 158 |       }
 159 |     },
 160 |     "node_modules/@esbuild/linux-arm": {
 161 |       "version": "0.25.9",
 162 |       "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.9.tgz",
 163 |       "integrity": "sha512-HBU2Xv78SMgaydBmdor38lg8YDnFKSARg1Q6AT0/y2ezUAKiZvc211RDFHlEZRFNRVhcMamiToo7bDx3VEOYQw==",
 164 |       "cpu": [
 165 |         "arm"
 166 |       ],
 167 |       "dev": true,
 168 |       "license": "MIT",
 169 |       "optional": true,
 170 |       "os": [
 171 |         "linux"
 172 |       ],
 173 |       "engines": {
 174 |         "node": ">=18"
 175 |       }
 176 |     },
 177 |     "node_modules/@esbuild/linux-arm64": {
 178 |       "version": "0.25.9",
 179 |       "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.9.tgz",
 180 |       "integrity": "sha512-BlB7bIcLT3G26urh5Dmse7fiLmLXnRlopw4s8DalgZ8ef79Jj4aUcYbk90g8iCa2467HX8SAIidbL7gsqXHdRw==",
 181 |       "cpu": [
 182 |         "arm64"
 183 |       ],
 184 |       "dev": true,
 185 |       "license": "MIT",
 186 |       "optional": true,
 187 |       "os": [
 188 |         "linux"
 189 |       ],
 190 |       "engines": {
 191 |         "node": ">=18"
 192 |       }
 193 |     },
 194 |     "node_modules/@esbuild/linux-ia32": {
 195 |       "version": "0.25.9",
 196 |       "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.9.tgz",
 197 |       "integrity": "sha512-e7S3MOJPZGp2QW6AK6+Ly81rC7oOSerQ+P8L0ta4FhVi+/j/v2yZzx5CqqDaWjtPFfYz21Vi1S0auHrap3Ma3A==",
 198 |       "cpu": [
 199 |         "ia32"
 200 |       ],
 201 |       "dev": true,
 202 |       "license": "MIT",
 203 |       "optional": true,
 204 |       "os": [
 205 |         "linux"
 206 |       ],
 207 |       "engines": {
 208 |         "node": ">=18"
 209 |       }
 210 |     },
 211 |     "node_modules/@esbuild/linux-loong64": {
 212 |       "version": "0.25.9",
 213 |       "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.9.tgz",
 214 |       "integrity": "sha512-Sbe10Bnn0oUAB2AalYztvGcK+o6YFFA/9829PhOCUS9vkJElXGdphz0A3DbMdP8gmKkqPmPcMJmJOrI3VYB1JQ==",
 215 |       "cpu": [
 216 |         "loong64"
 217 |       ],
 218 |       "dev": true,
 219 |       "license": "MIT",
 220 |       "optional": true,
 221 |       "os": [
 222 |         "linux"
 223 |       ],
 224 |       "engines": {
 225 |         "node": ">=18"
 226 |       }
 227 |     },
 228 |     "node_modules/@esbuild/linux-mips64el": {
 229 |       "version": "0.25.9",
 230 |       "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.9.tgz",
 231 |       "integrity": "sha512-YcM5br0mVyZw2jcQeLIkhWtKPeVfAerES5PvOzaDxVtIyZ2NUBZKNLjC5z3/fUlDgT6w89VsxP2qzNipOaaDyA==",
 232 |       "cpu": [
 233 |         "mips64el"
 234 |       ],
 235 |       "dev": true,
 236 |       "license": "MIT",
 237 |       "optional": true,
 238 |       "os": [
 239 |         "linux"
 240 |       ],
 241 |       "engines": {
 242 |         "node": ">=18"
 243 |       }
 244 |     },
 245 |     "node_modules/@esbuild/linux-ppc64": {
 246 |       "version": "0.25.9",
 247 |       "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.9.tgz",
 248 |       "integrity": "sha512-++0HQvasdo20JytyDpFvQtNrEsAgNG2CY1CLMwGXfFTKGBGQT3bOeLSYE2l1fYdvML5KUuwn9Z8L1EWe2tzs1w==",
 249 |       "cpu": [
 250 |         "ppc64"
 251 |       ],
 252 |       "dev": true,
 253 |       "license": "MIT",
 254 |       "optional": true,
 255 |       "os": [
 256 |         "linux"
 257 |       ],
 258 |       "engines": {
 259 |         "node": ">=18"
 260 |       }
 261 |     },
 262 |     "node_modules/@esbuild/linux-riscv64": {
 263 |       "version": "0.25.9",
 264 |       "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.9.tgz",
 265 |       "integrity": "sha512-uNIBa279Y3fkjV+2cUjx36xkx7eSjb8IvnL01eXUKXez/CBHNRw5ekCGMPM0BcmqBxBcdgUWuUXmVWwm4CH9kg==",
 266 |       "cpu": [
 267 |         "riscv64"
 268 |       ],
 269 |       "dev": true,
 270 |       "license": "MIT",
 271 |       "optional": true,
 272 |       "os": [
 273 |         "linux"
 274 |       ],
 275 |       "engines": {
 276 |         "node": ">=18"
 277 |       }
 278 |     },
 279 |     "node_modules/@esbuild/linux-s390x": {
 280 |       "version": "0.25.9",
 281 |       "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.9.tgz",
 282 |       "integrity": "sha512-Mfiphvp3MjC/lctb+7D287Xw1DGzqJPb/J2aHHcHxflUo+8tmN/6d4k6I2yFR7BVo5/g7x2Monq4+Yew0EHRIA==",
 283 |       "cpu": [
 284 |         "s390x"
 285 |       ],
 286 |       "dev": true,
 287 |       "license": "MIT",
 288 |       "optional": true,
 289 |       "os": [
 290 |         "linux"
 291 |       ],
 292 |       "engines": {
 293 |         "node": ">=18"
 294 |       }
 295 |     },
 296 |     "node_modules/@esbuild/linux-x64": {
 297 |       "version": "0.25.9",
 298 |       "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.9.tgz",
 299 |       "integrity": "sha512-iSwByxzRe48YVkmpbgoxVzn76BXjlYFXC7NvLYq+b+kDjyyk30J0JY47DIn8z1MO3K0oSl9fZoRmZPQI4Hklzg==",
 300 |       "cpu": [
 301 |         "x64"
 302 |       ],
 303 |       "dev": true,
 304 |       "license": "MIT",
 305 |       "optional": true,
 306 |       "os": [
 307 |         "linux"
 308 |       ],
 309 |       "engines": {
 310 |         "node": ">=18"
 311 |       }
 312 |     },
 313 |     "node_modules/@esbuild/netbsd-arm64": {
 314 |       "version": "0.25.9",
 315 |       "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.9.tgz",
 316 |       "integrity": "sha512-9jNJl6FqaUG+COdQMjSCGW4QiMHH88xWbvZ+kRVblZsWrkXlABuGdFJ1E9L7HK+T0Yqd4akKNa/lO0+jDxQD4Q==",
 317 |       "cpu": [
 318 |         "arm64"
 319 |       ],
 320 |       "dev": true,
 321 |       "license": "MIT",
 322 |       "optional": true,
 323 |       "os": [
 324 |         "netbsd"
 325 |       ],
 326 |       "engines": {
 327 |         "node": ">=18"
 328 |       }
 329 |     },
 330 |     "node_modules/@esbuild/netbsd-x64": {
 331 |       "version": "0.25.9",
 332 |       "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.9.tgz",
 333 |       "integrity": "sha512-RLLdkflmqRG8KanPGOU7Rpg829ZHu8nFy5Pqdi9U01VYtG9Y0zOG6Vr2z4/S+/3zIyOxiK6cCeYNWOFR9QP87g==",
 334 |       "cpu": [
 335 |         "x64"
 336 |       ],
 337 |       "dev": true,
 338 |       "license": "MIT",
 339 |       "optional": true,
 340 |       "os": [
 341 |         "netbsd"
 342 |       ],
 343 |       "engines": {
 344 |         "node": ">=18"
 345 |       }
 346 |     },
 347 |     "node_modules/@esbuild/openbsd-arm64": {
 348 |       "version": "0.25.9",
 349 |       "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.9.tgz",
 350 |       "integrity": "sha512-YaFBlPGeDasft5IIM+CQAhJAqS3St3nJzDEgsgFixcfZeyGPCd6eJBWzke5piZuZ7CtL656eOSYKk4Ls2C0FRQ==",
 351 |       "cpu": [
 352 |         "arm64"
 353 |       ],
 354 |       "dev": true,
 355 |       "license": "MIT",
 356 |       "optional": true,
 357 |       "os": [
 358 |         "openbsd"
 359 |       ],
 360 |       "engines": {
 361 |         "node": ">=18"
 362 |       }
 363 |     },
 364 |     "node_modules/@esbuild/openbsd-x64": {
 365 |       "version": "0.25.9",
 366 |       "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.9.tgz",
 367 |       "integrity": "sha512-1MkgTCuvMGWuqVtAvkpkXFmtL8XhWy+j4jaSO2wxfJtilVCi0ZE37b8uOdMItIHz4I6z1bWWtEX4CJwcKYLcuA==",
 368 |       "cpu": [
 369 |         "x64"
 370 |       ],
 371 |       "dev": true,
 372 |       "license": "MIT",
 373 |       "optional": true,
 374 |       "os": [
 375 |         "openbsd"
 376 |       ],
 377 |       "engines": {
 378 |         "node": ">=18"
 379 |       }
 380 |     },
 381 |     "node_modules/@esbuild/openharmony-arm64": {
 382 |       "version": "0.25.9",
 383 |       "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.9.tgz",
 384 |       "integrity": "sha512-4Xd0xNiMVXKh6Fa7HEJQbrpP3m3DDn43jKxMjxLLRjWnRsfxjORYJlXPO4JNcXtOyfajXorRKY9NkOpTHptErg==",
 385 |       "cpu": [
 386 |         "arm64"
 387 |       ],
 388 |       "dev": true,
 389 |       "license": "MIT",
 390 |       "optional": true,
 391 |       "os": [
 392 |         "openharmony"
 393 |       ],
 394 |       "engines": {
 395 |         "node": ">=18"
 396 |       }
 397 |     },
 398 |     "node_modules/@esbuild/sunos-x64": {
 399 |       "version": "0.25.9",
 400 |       "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.9.tgz",
 401 |       "integrity": "sha512-WjH4s6hzo00nNezhp3wFIAfmGZ8U7KtrJNlFMRKxiI9mxEK1scOMAaa9i4crUtu+tBr+0IN6JCuAcSBJZfnphw==",
 402 |       "cpu": [
 403 |         "x64"
 404 |       ],
 405 |       "dev": true,
 406 |       "license": "MIT",
 407 |       "optional": true,
 408 |       "os": [
 409 |         "sunos"
 410 |       ],
 411 |       "engines": {
 412 |         "node": ">=18"
 413 |       }
 414 |     },
 415 |     "node_modules/@esbuild/win32-arm64": {
 416 |       "version": "0.25.9",
 417 |       "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.9.tgz",
 418 |       "integrity": "sha512-mGFrVJHmZiRqmP8xFOc6b84/7xa5y5YvR1x8djzXpJBSv/UsNK6aqec+6JDjConTgvvQefdGhFDAs2DLAds6gQ==",
 419 |       "cpu": [
 420 |         "arm64"
 421 |       ],
 422 |       "dev": true,
 423 |       "license": "MIT",
 424 |       "optional": true,
 425 |       "os": [
 426 |         "win32"
 427 |       ],
 428 |       "engines": {
 429 |         "node": ">=18"
 430 |       }
 431 |     },
 432 |     "node_modules/@esbuild/win32-ia32": {
 433 |       "version": "0.25.9",
 434 |       "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.9.tgz",
 435 |       "integrity": "sha512-b33gLVU2k11nVx1OhX3C8QQP6UHQK4ZtN56oFWvVXvz2VkDoe6fbG8TOgHFxEvqeqohmRnIHe5A1+HADk4OQww==",
 436 |       "cpu": [
 437 |         "ia32"
 438 |       ],
 439 |       "dev": true,
 440 |       "license": "MIT",
 441 |       "optional": true,
 442 |       "os": [
 443 |         "win32"
 444 |       ],
 445 |       "engines": {
 446 |         "node": ">=18"
 447 |       }
 448 |     },
 449 |     "node_modules/@esbuild/win32-x64": {
 450 |       "version": "0.25.9",
 451 |       "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.9.tgz",
 452 |       "integrity": "sha512-PPOl1mi6lpLNQxnGoyAfschAodRFYXJ+9fs6WHXz7CSWKbOqiMZsubC+BQsVKuul+3vKLuwTHsS2c2y9EoKwxQ==",
 453 |       "cpu": [
 454 |         "x64"
 455 |       ],
 456 |       "dev": true,
 457 |       "license": "MIT",
 458 |       "optional": true,
 459 |       "os": [
 460 |         "win32"
 461 |       ],
 462 |       "engines": {
 463 |         "node": ">=18"
 464 |       }
 465 |     },
 466 |     "node_modules/@petamoriken/float16": {
 467 |       "version": "3.9.2",
 468 |       "resolved": "https://registry.npmjs.org/@petamoriken/float16/-/float16-3.9.2.tgz",
 469 |       "integrity": "sha512-VgffxawQde93xKxT3qap3OH+meZf7VaSB5Sqd4Rqc+FP5alWbpOyan/7tRbOAvynjpG3GpdtAuGU/NdhQpmrog==",
 470 |       "license": "MIT"
 471 |     },
 472 |     "node_modules/@rollup/rollup-android-arm-eabi": {
 473 |       "version": "4.50.1",
 474 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.50.1.tgz",
 475 |       "integrity": "sha512-HJXwzoZN4eYTdD8bVV22DN8gsPCAj3V20NHKOs8ezfXanGpmVPR7kalUHd+Y31IJp9stdB87VKPFbsGY3H/2ag==",
 476 |       "cpu": [
 477 |         "arm"
 478 |       ],
 479 |       "dev": true,
 480 |       "license": "MIT",
 481 |       "optional": true,
 482 |       "os": [
 483 |         "android"
 484 |       ]
 485 |     },
 486 |     "node_modules/@rollup/rollup-android-arm64": {
 487 |       "version": "4.50.1",
 488 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.50.1.tgz",
 489 |       "integrity": "sha512-PZlsJVcjHfcH53mOImyt3bc97Ep3FJDXRpk9sMdGX0qgLmY0EIWxCag6EigerGhLVuL8lDVYNnSo8qnTElO4xw==",
 490 |       "cpu": [
 491 |         "arm64"
 492 |       ],
 493 |       "dev": true,
 494 |       "license": "MIT",
 495 |       "optional": true,
 496 |       "os": [
 497 |         "android"
 498 |       ]
 499 |     },
 500 |     "node_modules/@rollup/rollup-darwin-arm64": {
 501 |       "version": "4.50.1",
 502 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.50.1.tgz",
 503 |       "integrity": "sha512-xc6i2AuWh++oGi4ylOFPmzJOEeAa2lJeGUGb4MudOtgfyyjr4UPNK+eEWTPLvmPJIY/pgw6ssFIox23SyrkkJw==",
 504 |       "cpu": [
 505 |         "arm64"
 506 |       ],
 507 |       "dev": true,
 508 |       "license": "MIT",
 509 |       "optional": true,
 510 |       "os": [
 511 |         "darwin"
 512 |       ]
 513 |     },
 514 |     "node_modules/@rollup/rollup-darwin-x64": {
 515 |       "version": "4.50.1",
 516 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.50.1.tgz",
 517 |       "integrity": "sha512-2ofU89lEpDYhdLAbRdeyz/kX3Y2lpYc6ShRnDjY35bZhd2ipuDMDi6ZTQ9NIag94K28nFMofdnKeHR7BT0CATw==",
 518 |       "cpu": [
 519 |         "x64"
 520 |       ],
 521 |       "dev": true,
 522 |       "license": "MIT",
 523 |       "optional": true,
 524 |       "os": [
 525 |         "darwin"
 526 |       ]
 527 |     },
 528 |     "node_modules/@rollup/rollup-freebsd-arm64": {
 529 |       "version": "4.50.1",
 530 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.50.1.tgz",
 531 |       "integrity": "sha512-wOsE6H2u6PxsHY/BeFHA4VGQN3KUJFZp7QJBmDYI983fgxq5Th8FDkVuERb2l9vDMs1D5XhOrhBrnqcEY6l8ZA==",
 532 |       "cpu": [
 533 |         "arm64"
 534 |       ],
 535 |       "dev": true,
 536 |       "license": "MIT",
 537 |       "optional": true,
 538 |       "os": [
 539 |         "freebsd"
 540 |       ]
 541 |     },
 542 |     "node_modules/@rollup/rollup-freebsd-x64": {
 543 |       "version": "4.50.1",
 544 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.50.1.tgz",
 545 |       "integrity": "sha512-A/xeqaHTlKbQggxCqispFAcNjycpUEHP52mwMQZUNqDUJFFYtPHCXS1VAG29uMlDzIVr+i00tSFWFLivMcoIBQ==",
 546 |       "cpu": [
 547 |         "x64"
 548 |       ],
 549 |       "dev": true,
 550 |       "license": "MIT",
 551 |       "optional": true,
 552 |       "os": [
 553 |         "freebsd"
 554 |       ]
 555 |     },
 556 |     "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
 557 |       "version": "4.50.1",
 558 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.50.1.tgz",
 559 |       "integrity": "sha512-54v4okehwl5TaSIkpp97rAHGp7t3ghinRd/vyC1iXqXMfjYUTm7TfYmCzXDoHUPTTf36L8pr0E7YsD3CfB3ZDg==",
 560 |       "cpu": [
 561 |         "arm"
 562 |       ],
 563 |       "dev": true,
 564 |       "license": "MIT",
 565 |       "optional": true,
 566 |       "os": [
 567 |         "linux"
 568 |       ]
 569 |     },
 570 |     "node_modules/@rollup/rollup-linux-arm-musleabihf": {
 571 |       "version": "4.50.1",
 572 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.50.1.tgz",
 573 |       "integrity": "sha512-p/LaFyajPN/0PUHjv8TNyxLiA7RwmDoVY3flXHPSzqrGcIp/c2FjwPPP5++u87DGHtw+5kSH5bCJz0mvXngYxw==",
 574 |       "cpu": [
 575 |         "arm"
 576 |       ],
 577 |       "dev": true,
 578 |       "license": "MIT",
 579 |       "optional": true,
 580 |       "os": [
 581 |         "linux"
 582 |       ]
 583 |     },
 584 |     "node_modules/@rollup/rollup-linux-arm64-gnu": {
 585 |       "version": "4.50.1",
 586 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.50.1.tgz",
 587 |       "integrity": "sha512-2AbMhFFkTo6Ptna1zO7kAXXDLi7H9fGTbVaIq2AAYO7yzcAsuTNWPHhb2aTA6GPiP+JXh85Y8CiS54iZoj4opw==",
 588 |       "cpu": [
 589 |         "arm64"
 590 |       ],
 591 |       "dev": true,
 592 |       "license": "MIT",
 593 |       "optional": true,
 594 |       "os": [
 595 |         "linux"
 596 |       ]
 597 |     },
 598 |     "node_modules/@rollup/rollup-linux-arm64-musl": {
 599 |       "version": "4.50.1",
 600 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.50.1.tgz",
 601 |       "integrity": "sha512-Cgef+5aZwuvesQNw9eX7g19FfKX5/pQRIyhoXLCiBOrWopjo7ycfB292TX9MDcDijiuIJlx1IzJz3IoCPfqs9w==",
 602 |       "cpu": [
 603 |         "arm64"
 604 |       ],
 605 |       "dev": true,
 606 |       "license": "MIT",
 607 |       "optional": true,
 608 |       "os": [
 609 |         "linux"
 610 |       ]
 611 |     },
 612 |     "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
 613 |       "version": "4.50.1",
 614 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.50.1.tgz",
 615 |       "integrity": "sha512-RPhTwWMzpYYrHrJAS7CmpdtHNKtt2Ueo+BlLBjfZEhYBhK00OsEqM08/7f+eohiF6poe0YRDDd8nAvwtE/Y62Q==",
 616 |       "cpu": [
 617 |         "loong64"
 618 |       ],
 619 |       "dev": true,
 620 |       "license": "MIT",
 621 |       "optional": true,
 622 |       "os": [
 623 |         "linux"
 624 |       ]
 625 |     },
 626 |     "node_modules/@rollup/rollup-linux-ppc64-gnu": {
 627 |       "version": "4.50.1",
 628 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.50.1.tgz",
 629 |       "integrity": "sha512-eSGMVQw9iekut62O7eBdbiccRguuDgiPMsw++BVUg+1K7WjZXHOg/YOT9SWMzPZA+w98G+Fa1VqJgHZOHHnY0Q==",
 630 |       "cpu": [
 631 |         "ppc64"
 632 |       ],
 633 |       "dev": true,
 634 |       "license": "MIT",
 635 |       "optional": true,
 636 |       "os": [
 637 |         "linux"
 638 |       ]
 639 |     },
 640 |     "node_modules/@rollup/rollup-linux-riscv64-gnu": {
 641 |       "version": "4.50.1",
 642 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.50.1.tgz",
 643 |       "integrity": "sha512-S208ojx8a4ciIPrLgazF6AgdcNJzQE4+S9rsmOmDJkusvctii+ZvEuIC4v/xFqzbuP8yDjn73oBlNDgF6YGSXQ==",
 644 |       "cpu": [
 645 |         "riscv64"
 646 |       ],
 647 |       "dev": true,
 648 |       "license": "MIT",
 649 |       "optional": true,
 650 |       "os": [
 651 |         "linux"
 652 |       ]
 653 |     },
 654 |     "node_modules/@rollup/rollup-linux-riscv64-musl": {
 655 |       "version": "4.50.1",
 656 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.50.1.tgz",
 657 |       "integrity": "sha512-3Ag8Ls1ggqkGUvSZWYcdgFwriy2lWo+0QlYgEFra/5JGtAd6C5Hw59oojx1DeqcA2Wds2ayRgvJ4qxVTzCHgzg==",
 658 |       "cpu": [
 659 |         "riscv64"
 660 |       ],
 661 |       "dev": true,
 662 |       "license": "MIT",
 663 |       "optional": true,
 664 |       "os": [
 665 |         "linux"
 666 |       ]
 667 |     },
 668 |     "node_modules/@rollup/rollup-linux-s390x-gnu": {
 669 |       "version": "4.50.1",
 670 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.50.1.tgz",
 671 |       "integrity": "sha512-t9YrKfaxCYe7l7ldFERE1BRg/4TATxIg+YieHQ966jwvo7ddHJxPj9cNFWLAzhkVsbBvNA4qTbPVNsZKBO4NSg==",
 672 |       "cpu": [
 673 |         "s390x"
 674 |       ],
 675 |       "dev": true,
 676 |       "license": "MIT",
 677 |       "optional": true,
 678 |       "os": [
 679 |         "linux"
 680 |       ]
 681 |     },
 682 |     "node_modules/@rollup/rollup-linux-x64-gnu": {
 683 |       "version": "4.50.1",
 684 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.50.1.tgz",
 685 |       "integrity": "sha512-MCgtFB2+SVNuQmmjHf+wfI4CMxy3Tk8XjA5Z//A0AKD7QXUYFMQcns91K6dEHBvZPCnhJSyDWLApk40Iq/H3tA==",
 686 |       "cpu": [
 687 |         "x64"
 688 |       ],
 689 |       "dev": true,
 690 |       "license": "MIT",
 691 |       "optional": true,
 692 |       "os": [
 693 |         "linux"
 694 |       ]
 695 |     },
 696 |     "node_modules/@rollup/rollup-linux-x64-musl": {
 697 |       "version": "4.50.1",
 698 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.50.1.tgz",
 699 |       "integrity": "sha512-nEvqG+0jeRmqaUMuwzlfMKwcIVffy/9KGbAGyoa26iu6eSngAYQ512bMXuqqPrlTyfqdlB9FVINs93j534UJrg==",
 700 |       "cpu": [
 701 |         "x64"
 702 |       ],
 703 |       "dev": true,
 704 |       "license": "MIT",
 705 |       "optional": true,
 706 |       "os": [
 707 |         "linux"
 708 |       ]
 709 |     },
 710 |     "node_modules/@rollup/rollup-openharmony-arm64": {
 711 |       "version": "4.50.1",
 712 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.50.1.tgz",
 713 |       "integrity": "sha512-RDsLm+phmT3MJd9SNxA9MNuEAO/J2fhW8GXk62G/B4G7sLVumNFbRwDL6v5NrESb48k+QMqdGbHgEtfU0LCpbA==",
 714 |       "cpu": [
 715 |         "arm64"
 716 |       ],
 717 |       "dev": true,
 718 |       "license": "MIT",
 719 |       "optional": true,
 720 |       "os": [
 721 |         "openharmony"
 722 |       ]
 723 |     },
 724 |     "node_modules/@rollup/rollup-win32-arm64-msvc": {
 725 |       "version": "4.50.1",
 726 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.50.1.tgz",
 727 |       "integrity": "sha512-hpZB/TImk2FlAFAIsoElM3tLzq57uxnGYwplg6WDyAxbYczSi8O2eQ+H2Lx74504rwKtZ3N2g4bCUkiamzS6TQ==",
 728 |       "cpu": [
 729 |         "arm64"
 730 |       ],
 731 |       "dev": true,
 732 |       "license": "MIT",
 733 |       "optional": true,
 734 |       "os": [
 735 |         "win32"
 736 |       ]
 737 |     },
 738 |     "node_modules/@rollup/rollup-win32-ia32-msvc": {
 739 |       "version": "4.50.1",
 740 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.50.1.tgz",
 741 |       "integrity": "sha512-SXjv8JlbzKM0fTJidX4eVsH+Wmnp0/WcD8gJxIZyR6Gay5Qcsmdbi9zVtnbkGPG8v2vMR1AD06lGWy5FLMcG7A==",
 742 |       "cpu": [
 743 |         "ia32"
 744 |       ],
 745 |       "dev": true,
 746 |       "license": "MIT",
 747 |       "optional": true,
 748 |       "os": [
 749 |         "win32"
 750 |       ]
 751 |     },
 752 |     "node_modules/@rollup/rollup-win32-x64-msvc": {
 753 |       "version": "4.50.1",
 754 |       "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.50.1.tgz",
 755 |       "integrity": "sha512-StxAO/8ts62KZVRAm4JZYq9+NqNsV7RvimNK+YM7ry//zebEH6meuugqW/P5OFUCjyQgui+9fUxT6d5NShvMvA==",
 756 |       "cpu": [
 757 |         "x64"
 758 |       ],
 759 |       "dev": true,
 760 |       "license": "MIT",
 761 |       "optional": true,
 762 |       "os": [
 763 |         "win32"
 764 |       ]
 765 |     },
 766 |     "node_modules/@types/estree": {
 767 |       "version": "1.0.8",
 768 |       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
 769 |       "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
 770 |       "dev": true,
 771 |       "license": "MIT"
 772 |     },
 773 |     "node_modules/@types/rbush": {
 774 |       "version": "4.0.0",
 775 |       "resolved": "https://registry.npmjs.org/@types/rbush/-/rbush-4.0.0.tgz",
 776 |       "integrity": "sha512-+N+2H39P8X+Hy1I5mC6awlTX54k3FhiUmvt7HWzGJZvF+syUAAxP/stwppS8JE84YHqFgRMv6fCy31202CMFxQ==",
 777 |       "license": "MIT"
 778 |     },
 779 |     "node_modules/earcut": {
 780 |       "version": "3.0.2",
 781 |       "resolved": "https://registry.npmjs.org/earcut/-/earcut-3.0.2.tgz",
 782 |       "integrity": "sha512-X7hshQbLyMJ/3RPhyObLARM2sNxxmRALLKx1+NVFFnQ9gKzmCrxm9+uLIAdBcvc8FNLpctqlQ2V6AE92Ol9UDQ==",
 783 |       "license": "ISC"
 784 |     },
 785 |     "node_modules/esbuild": {
 786 |       "version": "0.25.9",
 787 |       "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.9.tgz",
 788 |       "integrity": "sha512-CRbODhYyQx3qp7ZEwzxOk4JBqmD/seJrzPa/cGjY1VtIn5E09Oi9/dB4JwctnfZ8Q8iT7rioVv5k/FNT/uf54g==",
 789 |       "dev": true,
 790 |       "hasInstallScript": true,
 791 |       "license": "MIT",
 792 |       "bin": {
 793 |         "esbuild": "bin/esbuild"
 794 |       },
 795 |       "engines": {
 796 |         "node": ">=18"
 797 |       },
 798 |       "optionalDependencies": {
 799 |         "@esbuild/aix-ppc64": "0.25.9",
 800 |         "@esbuild/android-arm": "0.25.9",
 801 |         "@esbuild/android-arm64": "0.25.9",
 802 |         "@esbuild/android-x64": "0.25.9",
 803 |         "@esbuild/darwin-arm64": "0.25.9",
 804 |         "@esbuild/darwin-x64": "0.25.9",
 805 |         "@esbuild/freebsd-arm64": "0.25.9",
 806 |         "@esbuild/freebsd-x64": "0.25.9",
 807 |         "@esbuild/linux-arm": "0.25.9",
 808 |         "@esbuild/linux-arm64": "0.25.9",
 809 |         "@esbuild/linux-ia32": "0.25.9",
 810 |         "@esbuild/linux-loong64": "0.25.9",
 811 |         "@esbuild/linux-mips64el": "0.25.9",
 812 |         "@esbuild/linux-ppc64": "0.25.9",
 813 |         "@esbuild/linux-riscv64": "0.25.9",
 814 |         "@esbuild/linux-s390x": "0.25.9",
 815 |         "@esbuild/linux-x64": "0.25.9",
 816 |         "@esbuild/netbsd-arm64": "0.25.9",
 817 |         "@esbuild/netbsd-x64": "0.25.9",
 818 |         "@esbuild/openbsd-arm64": "0.25.9",
 819 |         "@esbuild/openbsd-x64": "0.25.9",
 820 |         "@esbuild/openharmony-arm64": "0.25.9",
 821 |         "@esbuild/sunos-x64": "0.25.9",
 822 |         "@esbuild/win32-arm64": "0.25.9",
 823 |         "@esbuild/win32-ia32": "0.25.9",
 824 |         "@esbuild/win32-x64": "0.25.9"
 825 |       }
 826 |     },
 827 |     "node_modules/fdir": {
 828 |       "version": "6.5.0",
 829 |       "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
 830 |       "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
 831 |       "dev": true,
 832 |       "license": "MIT",
 833 |       "engines": {
 834 |         "node": ">=12.0.0"
 835 |       },
 836 |       "peerDependencies": {
 837 |         "picomatch": "^3 || ^4"
 838 |       },
 839 |       "peerDependenciesMeta": {
 840 |         "picomatch": {
 841 |           "optional": true
 842 |         }
 843 |       }
 844 |     },
 845 |     "node_modules/fsevents": {
 846 |       "version": "2.3.3",
 847 |       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
 848 |       "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
 849 |       "dev": true,
 850 |       "hasInstallScript": true,
 851 |       "license": "MIT",
 852 |       "optional": true,
 853 |       "os": [
 854 |         "darwin"
 855 |       ],
 856 |       "engines": {
 857 |         "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
 858 |       }
 859 |     },
 860 |     "node_modules/geotiff": {
 861 |       "version": "2.1.3",
 862 |       "resolved": "https://registry.npmjs.org/geotiff/-/geotiff-2.1.3.tgz",
 863 |       "integrity": "sha512-PT6uoF5a1+kbC3tHmZSUsLHBp2QJlHasxxxxPW47QIY1VBKpFB+FcDvX+MxER6UzgLQZ0xDzJ9s48B9JbOCTqA==",
 864 |       "license": "MIT",
 865 |       "dependencies": {
 866 |         "@petamoriken/float16": "^3.4.7",
 867 |         "lerc": "^3.0.0",
 868 |         "pako": "^2.0.4",
 869 |         "parse-headers": "^2.0.2",
 870 |         "quick-lru": "^6.1.1",
 871 |         "web-worker": "^1.2.0",
 872 |         "xml-utils": "^1.0.2",
 873 |         "zstddec": "^0.1.0"
 874 |       },
 875 |       "engines": {
 876 |         "node": ">=10.19"
 877 |       }
 878 |     },
 879 |     "node_modules/lerc": {
 880 |       "version": "3.0.0",
 881 |       "resolved": "https://registry.npmjs.org/lerc/-/lerc-3.0.0.tgz",
 882 |       "integrity": "sha512-Rm4J/WaHhRa93nCN2mwWDZFoRVF18G1f47C+kvQWyHGEZxFpTUi73p7lMVSAndyxGt6lJ2/CFbOcf9ra5p8aww==",
 883 |       "license": "Apache-2.0"
 884 |     },
 885 |     "node_modules/nanoid": {
 886 |       "version": "3.3.11",
 887 |       "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
 888 |       "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
 889 |       "dev": true,
 890 |       "funding": [
 891 |         {
 892 |           "type": "github",
 893 |           "url": "https://github.com/sponsors/ai"
 894 |         }
 895 |       ],
 896 |       "license": "MIT",
 897 |       "bin": {
 898 |         "nanoid": "bin/nanoid.cjs"
 899 |       },
 900 |       "engines": {
 901 |         "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
 902 |       }
 903 |     },
 904 |     "node_modules/ol": {
 905 |       "version": "10.6.1",
 906 |       "resolved": "https://registry.npmjs.org/ol/-/ol-10.6.1.tgz",
 907 |       "integrity": "sha512-xp174YOwPeLj7c7/8TCIEHQ4d41tgTDDhdv6SqNdySsql5/MaFJEJkjlsYcvOPt7xA6vrum/QG4UdJ0iCGT1cg==",
 908 |       "license": "BSD-2-Clause",
 909 |       "dependencies": {
 910 |         "@types/rbush": "4.0.0",
 911 |         "earcut": "^3.0.0",
 912 |         "geotiff": "^2.1.3",
 913 |         "pbf": "4.0.1",
 914 |         "rbush": "^4.0.0"
 915 |       },
 916 |       "funding": {
 917 |         "type": "opencollective",
 918 |         "url": "https://opencollective.com/openlayers"
 919 |       }
 920 |     },
 921 |     "node_modules/pako": {
 922 |       "version": "2.1.0",
 923 |       "resolved": "https://registry.npmjs.org/pako/-/pako-2.1.0.tgz",
 924 |       "integrity": "sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==",
 925 |       "license": "(MIT AND Zlib)"
 926 |     },
 927 |     "node_modules/parse-headers": {
 928 |       "version": "2.0.6",
 929 |       "resolved": "https://registry.npmjs.org/parse-headers/-/parse-headers-2.0.6.tgz",
 930 |       "integrity": "sha512-Tz11t3uKztEW5FEVZnj1ox8GKblWn+PvHY9TmJV5Mll2uHEwRdR/5Li1OlXoECjLYkApdhWy44ocONwXLiKO5A==",
 931 |       "license": "MIT"
 932 |     },
 933 |     "node_modules/pbf": {
 934 |       "version": "4.0.1",
 935 |       "resolved": "https://registry.npmjs.org/pbf/-/pbf-4.0.1.tgz",
 936 |       "integrity": "sha512-SuLdBvS42z33m8ejRbInMapQe8n0D3vN/Xd5fmWM3tufNgRQFBpaW2YVJxQZV4iPNqb0vEFvssMEo5w9c6BTIA==",
 937 |       "license": "BSD-3-Clause",
 938 |       "dependencies": {
 939 |         "resolve-protobuf-schema": "^2.1.0"
 940 |       },
 941 |       "bin": {
 942 |         "pbf": "bin/pbf"
 943 |       }
 944 |     },
 945 |     "node_modules/picocolors": {
 946 |       "version": "1.1.1",
 947 |       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
 948 |       "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
 949 |       "dev": true,
 950 |       "license": "ISC"
 951 |     },
 952 |     "node_modules/picomatch": {
 953 |       "version": "4.0.3",
 954 |       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
 955 |       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
 956 |       "dev": true,
 957 |       "license": "MIT",
 958 |       "engines": {
 959 |         "node": ">=12"
 960 |       },
 961 |       "funding": {
 962 |         "url": "https://github.com/sponsors/jonschlinkert"
 963 |       }
 964 |     },
 965 |     "node_modules/postcss": {
 966 |       "version": "8.5.6",
 967 |       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
 968 |       "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
 969 |       "dev": true,
 970 |       "funding": [
 971 |         {
 972 |           "type": "opencollective",
 973 |           "url": "https://opencollective.com/postcss/"
 974 |         },
 975 |         {
 976 |           "type": "tidelift",
 977 |           "url": "https://tidelift.com/funding/github/npm/postcss"
 978 |         },
 979 |         {
 980 |           "type": "github",
 981 |           "url": "https://github.com/sponsors/ai"
 982 |         }
 983 |       ],
 984 |       "license": "MIT",
 985 |       "dependencies": {
 986 |         "nanoid": "^3.3.11",
 987 |         "picocolors": "^1.1.1",
 988 |         "source-map-js": "^1.2.1"
 989 |       },
 990 |       "engines": {
 991 |         "node": "^10 || ^12 || >=14"
 992 |       }
 993 |     },
 994 |     "node_modules/protocol-buffers-schema": {
 995 |       "version": "3.6.0",
 996 |       "resolved": "https://registry.npmjs.org/protocol-buffers-schema/-/protocol-buffers-schema-3.6.0.tgz",
 997 |       "integrity": "sha512-TdDRD+/QNdrCGCE7v8340QyuXd4kIWIgapsE2+n/SaGiSSbomYl4TjHlvIoCWRpE7wFt02EpB35VVA2ImcBVqw==",
 998 |       "license": "MIT"
 999 |     },
1000 |     "node_modules/quick-lru": {
1001 |       "version": "6.1.2",
1002 |       "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-6.1.2.tgz",
1003 |       "integrity": "sha512-AAFUA5O1d83pIHEhJwWCq/RQcRukCkn/NSm2QsTEMle5f2hP0ChI2+3Xb051PZCkLryI/Ir1MVKviT2FIloaTQ==",
1004 |       "license": "MIT",
1005 |       "engines": {
1006 |         "node": ">=12"
1007 |       },
1008 |       "funding": {
1009 |         "url": "https://github.com/sponsors/sindresorhus"
1010 |       }
1011 |     },
1012 |     "node_modules/quickselect": {
1013 |       "version": "3.0.0",
1014 |       "resolved": "https://registry.npmjs.org/quickselect/-/quickselect-3.0.0.tgz",
1015 |       "integrity": "sha512-XdjUArbK4Bm5fLLvlm5KpTFOiOThgfWWI4axAZDWg4E/0mKdZyI9tNEfds27qCi1ze/vwTR16kvmmGhRra3c2g==",
1016 |       "license": "ISC"
1017 |     },
1018 |     "node_modules/rbush": {
1019 |       "version": "4.0.1",
1020 |       "resolved": "https://registry.npmjs.org/rbush/-/rbush-4.0.1.tgz",
1021 |       "integrity": "sha512-IP0UpfeWQujYC8Jg162rMNc01Rf0gWMMAb2Uxus/Q0qOFw4lCcq6ZnQEZwUoJqWyUGJ9th7JjwI4yIWo+uvoAQ==",
1022 |       "license": "MIT",
1023 |       "dependencies": {
1024 |         "quickselect": "^3.0.0"
1025 |       }
1026 |     },
1027 |     "node_modules/resolve-protobuf-schema": {
1028 |       "version": "2.1.0",
1029 |       "resolved": "https://registry.npmjs.org/resolve-protobuf-schema/-/resolve-protobuf-schema-2.1.0.tgz",
1030 |       "integrity": "sha512-kI5ffTiZWmJaS/huM8wZfEMer1eRd7oJQhDuxeCLe3t7N7mX3z94CN0xPxBQxFYQTSNz9T0i+v6inKqSdK8xrQ==",
1031 |       "license": "MIT",
1032 |       "dependencies": {
1033 |         "protocol-buffers-schema": "^3.3.1"
1034 |       }
1035 |     },
1036 |     "node_modules/rollup": {
1037 |       "version": "4.50.1",
1038 |       "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.50.1.tgz",
1039 |       "integrity": "sha512-78E9voJHwnXQMiQdiqswVLZwJIzdBKJ1GdI5Zx6XwoFKUIk09/sSrr+05QFzvYb8q6Y9pPV45zzDuYa3907TZA==",
1040 |       "dev": true,
1041 |       "license": "MIT",
1042 |       "dependencies": {
1043 |         "@types/estree": "1.0.8"
1044 |       },
1045 |       "bin": {
1046 |         "rollup": "dist/bin/rollup"
1047 |       },
1048 |       "engines": {
1049 |         "node": ">=18.0.0",
1050 |         "npm": ">=8.0.0"
1051 |       },
1052 |       "optionalDependencies": {
1053 |         "@rollup/rollup-android-arm-eabi": "4.50.1",
1054 |         "@rollup/rollup-android-arm64": "4.50.1",
1055 |         "@rollup/rollup-darwin-arm64": "4.50.1",
1056 |         "@rollup/rollup-darwin-x64": "4.50.1",
1057 |         "@rollup/rollup-freebsd-arm64": "4.50.1",
1058 |         "@rollup/rollup-freebsd-x64": "4.50.1",
1059 |         "@rollup/rollup-linux-arm-gnueabihf": "4.50.1",
1060 |         "@rollup/rollup-linux-arm-musleabihf": "4.50.1",
1061 |         "@rollup/rollup-linux-arm64-gnu": "4.50.1",
1062 |         "@rollup/rollup-linux-arm64-musl": "4.50.1",
1063 |         "@rollup/rollup-linux-loongarch64-gnu": "4.50.1",
1064 |         "@rollup/rollup-linux-ppc64-gnu": "4.50.1",
1065 |         "@rollup/rollup-linux-riscv64-gnu": "4.50.1",
1066 |         "@rollup/rollup-linux-riscv64-musl": "4.50.1",
1067 |         "@rollup/rollup-linux-s390x-gnu": "4.50.1",
1068 |         "@rollup/rollup-linux-x64-gnu": "4.50.1",
1069 |         "@rollup/rollup-linux-x64-musl": "4.50.1",
1070 |         "@rollup/rollup-openharmony-arm64": "4.50.1",
1071 |         "@rollup/rollup-win32-arm64-msvc": "4.50.1",
1072 |         "@rollup/rollup-win32-ia32-msvc": "4.50.1",
1073 |         "@rollup/rollup-win32-x64-msvc": "4.50.1",
1074 |         "fsevents": "~2.3.2"
1075 |       }
1076 |     },
1077 |     "node_modules/source-map-js": {
1078 |       "version": "1.2.1",
1079 |       "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
1080 |       "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
1081 |       "dev": true,
1082 |       "license": "BSD-3-Clause",
1083 |       "engines": {
1084 |         "node": ">=0.10.0"
1085 |       }
1086 |     },
1087 |     "node_modules/tinyglobby": {
1088 |       "version": "0.2.15",
1089 |       "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
1090 |       "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
1091 |       "dev": true,
1092 |       "license": "MIT",
1093 |       "dependencies": {
1094 |         "fdir": "^6.5.0",
1095 |         "picomatch": "^4.0.3"
1096 |       },
1097 |       "engines": {
1098 |         "node": ">=12.0.0"
1099 |       },
1100 |       "funding": {
1101 |         "url": "https://github.com/sponsors/SuperchupuDev"
1102 |       }
1103 |     },
1104 |     "node_modules/vite": {
1105 |       "version": "7.1.11",
1106 |       "resolved": "https://registry.npmjs.org/vite/-/vite-7.1.11.tgz",
1107 |       "integrity": "sha512-uzcxnSDVjAopEUjljkWh8EIrg6tlzrjFUfMcR1EVsRDGwf/ccef0qQPRyOrROwhrTDaApueq+ja+KLPlzR/zdg==",
1108 |       "dev": true,
1109 |       "license": "MIT",
1110 |       "dependencies": {
1111 |         "esbuild": "^0.25.0",
1112 |         "fdir": "^6.5.0",
1113 |         "picomatch": "^4.0.3",
1114 |         "postcss": "^8.5.6",
1115 |         "rollup": "^4.43.0",
1116 |         "tinyglobby": "^0.2.15"
1117 |       },
1118 |       "bin": {
1119 |         "vite": "bin/vite.js"
1120 |       },
1121 |       "engines": {
1122 |         "node": "^20.19.0 || >=22.12.0"
1123 |       },
1124 |       "funding": {
1125 |         "url": "https://github.com/vitejs/vite?sponsor=1"
1126 |       },
1127 |       "optionalDependencies": {
1128 |         "fsevents": "~2.3.3"
1129 |       },
1130 |       "peerDependencies": {
1131 |         "@types/node": "^20.19.0 || >=22.12.0",
1132 |         "jiti": ">=1.21.0",
1133 |         "less": "^4.0.0",
1134 |         "lightningcss": "^1.21.0",
1135 |         "sass": "^1.70.0",
1136 |         "sass-embedded": "^1.70.0",
1137 |         "stylus": ">=0.54.8",
1138 |         "sugarss": "^5.0.0",
1139 |         "terser": "^5.16.0",
1140 |         "tsx": "^4.8.1",
1141 |         "yaml": "^2.4.2"
1142 |       },
1143 |       "peerDependenciesMeta": {
1144 |         "@types/node": {
1145 |           "optional": true
1146 |         },
1147 |         "jiti": {
1148 |           "optional": true
1149 |         },
1150 |         "less": {
1151 |           "optional": true
1152 |         },
1153 |         "lightningcss": {
1154 |           "optional": true
1155 |         },
1156 |         "sass": {
1157 |           "optional": true
1158 |         },
1159 |         "sass-embedded": {
1160 |           "optional": true
1161 |         },
1162 |         "stylus": {
1163 |           "optional": true
1164 |         },
1165 |         "sugarss": {
1166 |           "optional": true
1167 |         },
1168 |         "terser": {
1169 |           "optional": true
1170 |         },
1171 |         "tsx": {
1172 |           "optional": true
1173 |         },
1174 |         "yaml": {
1175 |           "optional": true
1176 |         }
1177 |       }
1178 |     },
1179 |     "node_modules/web-worker": {
1180 |       "version": "1.5.0",
1181 |       "resolved": "https://registry.npmjs.org/web-worker/-/web-worker-1.5.0.tgz",
1182 |       "integrity": "sha512-RiMReJrTAiA+mBjGONMnjVDP2u3p9R1vkcGz6gDIrOMT3oGuYwX2WRMYI9ipkphSuE5XKEhydbhNEJh4NY9mlw==",
1183 |       "license": "Apache-2.0"
1184 |     },
1185 |     "node_modules/wgpu-layers": {
1186 |       "resolved": "../pkg",
1187 |       "link": true
1188 |     },
1189 |     "node_modules/xml-utils": {
1190 |       "version": "1.10.2",
1191 |       "resolved": "https://registry.npmjs.org/xml-utils/-/xml-utils-1.10.2.tgz",
1192 |       "integrity": "sha512-RqM+2o1RYs6T8+3DzDSoTRAUfrvaejbVHcp3+thnAtDKo8LskR+HomLajEy5UjTz24rpka7AxVBRR3g2wTUkJA==",
1193 |       "license": "CC0-1.0"
1194 |     },
1195 |     "node_modules/zstddec": {
1196 |       "version": "0.1.0",
1197 |       "resolved": "https://registry.npmjs.org/zstddec/-/zstddec-0.1.0.tgz",
1198 |       "integrity": "sha512-w2NTI8+3l3eeltKAdK8QpiLo/flRAr2p8AGeakfMZOXBxOg9HIu4LVDxBi81sYgVhFhdJjv1OrB5ssI8uFPoLg==",
1199 |       "license": "MIT AND BSD-3-Clause"
1200 |     }
1201 |   }
1202 | }
1203 | 


--------------------------------------------------------------------------------