leptos-helios 0.8.1

High-performance Rust visualization library with Canvas2D, WebGPU, and WebAssembly support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Shader management for WebGPU rendering

use super::types::{WebGpuError, WebGpuShader};
use std::collections::HashMap;
use std::sync::Arc;

/// Shader manager for WebGPU shaders
pub struct ShaderManager {
    device: Arc<wgpu::Device>,
    shader_cache: HashMap<String, wgpu::ShaderModule>,
    render_pipelines: HashMap<String, wgpu::RenderPipeline>,
}

impl ShaderManager {
    /// Create a new shader manager
    pub fn new(device: Arc<wgpu::Device>) -> Self {
        Self {
            device,
            shader_cache: HashMap::new(),
            render_pipelines: HashMap::new(),
        }
    }

    /// Compile a shader from source
    pub fn compile_shader(&mut self, shader: &WebGpuShader) -> Result<wgpu::ShaderModule, WebGpuError> {
        // Check cache first
        if let Some(cached_shader) = self.shader_cache.get(&shader.name) {
            return Ok(cached_shader.clone());
        }

        // Compile new shader
        let shader_module = self.device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some(&shader.name),
            source: wgpu::ShaderSource::Wgsl(shader.source.clone().into()),
        });

        // Cache the compiled shader
        self.shader_cache.insert(shader.name.clone(), shader_module.clone());

        Ok(shader_module)
    }

    /// Get a cached shader module
    pub fn get_shader(&self, name: &str) -> Option<&wgpu::ShaderModule> {
        self.shader_cache.get(name)
    }

    /// Create a render pipeline
    pub fn create_render_pipeline(
        &mut self,
        name: &str,
        shader_module: &wgpu::ShaderModule,
        vertex_buffer_layouts: &[wgpu::VertexBufferLayout],
        color_targets: &[Option<wgpu::ColorTargetState>],
    ) -> Result<wgpu::RenderPipeline, WebGpuError> {
        let pipeline = self.device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some(name),
            layout: None, // Use automatic layout
            vertex: wgpu::VertexState {
                module: shader_module,
                entry_point: Some("vs_main"),
                buffers: vertex_buffer_layouts,
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            },
            fragment: Some(wgpu::FragmentState {
                module: shader_module,
                entry_point: Some("fs_main"),
                targets: color_targets,
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            }),
            primitive: wgpu::PrimitiveState {
                topology: wgpu::PrimitiveTopology::TriangleList,
                strip_index_format: None,
                front_face: wgpu::FrontFace::Ccw,
                cull_mode: Some(wgpu::Face::Back),
                polygon_mode: wgpu::PolygonMode::Fill,
                unclipped_depth: false,
                conservative: false,
            },
            depth_stencil: None,
            multisample: wgpu::MultisampleState {
                count: 1,
                mask: !0,
                alpha_to_coverage_enabled: false,
            },
            cache: None,
            multiview: None,
        });

        // Cache the pipeline
        self.render_pipelines.insert(name.to_string(), pipeline.clone());

        Ok(pipeline)
    }

    /// Get a cached render pipeline
    pub fn get_render_pipeline(&self, name: &str) -> Option<&wgpu::RenderPipeline> {
        self.render_pipelines.get(name)
    }

    /// Clear shader cache
    pub fn clear_cache(&mut self) {
        self.shader_cache.clear();
        self.render_pipelines.clear();
    }

    /// Get shader cache statistics
    pub fn get_cache_stats(&self) -> (usize, usize) {
        (self.shader_cache.len(), self.render_pipelines.len())
    }
}

impl WebGpuShader {
    /// Create a new shader definition
    pub fn new(name: String, source: String, entry_point: String) -> Self {
        Self {
            name,
            source,
            entry_point,
        }
    }

    /// Create a basic vertex shader
    pub fn basic_vertex() -> Self {
        Self::new(
            "basic_vertex".to_string(),
            include_str!("shaders/basic_vertex.wgsl").to_string(),
            "vs_main".to_string(),
        )
    }

    /// Create a basic fragment shader
    pub fn basic_fragment() -> Self {
        Self::new(
            "basic_fragment".to_string(),
            include_str!("shaders/basic_fragment.wgsl").to_string(),
            "fs_main".to_string(),
        )
    }
}