use modules and str's for the compiled identifier mapping.

This makes the webgl renderer backend compile safe.

Author: ajakubowicz-canva

sparse_strips/vello_hybrid/src/render/webgl.rs

@@ -31,8 +31,7 @@ use alloc::vec::Vec;
 use bytemuck::{Pod, Zeroable};
 use core::{fmt::Debug, mem};
 use vello_common::{coarse::WideTile, tile::Tile};
-use vello_sparse_shaders::shaders::{clear_slots, render_strips};
-use vello_sparse_shaders::types::ReflectionMap;
+use vello_sparse_shaders::{clear_slots, render_strips};
 use web_sys::wasm_bindgen::{JsCast, JsValue};
 use web_sys::{
     WebGl2RenderingContext, WebGlBuffer, WebGlFramebuffer, WebGlProgram, WebGlTexture,
@@ -254,22 +253,19 @@ struct ClearSlotsConfig {
 impl WebGlPrograms {
     /// Creates programs and initializes resources.
     fn new(gl: WebGl2RenderingContext, slot_count: usize) -> Self {
-        let strip_glsl = render_strips();
-        let clear_glsl = clear_slots();
-
-        let strip_program =
-            create_shader_program(&gl, strip_glsl.vertex.source, strip_glsl.fragment.source);
-        let clear_program =
-            create_shader_program(&gl, clear_glsl.vertex.source, clear_glsl.fragment.source);
-
-        let strip_uniforms = get_strip_uniforms(
+        let strip_program = create_shader_program(
             &gl,
-            &strip_program,
-            &strip_glsl.vertex.reflection_map,
-            &strip_glsl.fragment.reflection_map,
+            render_strips::VERTEX_SOURCE,
+            render_strips::FRAGMENT_SOURCE,
         );
-        let clear_uniforms =
-            get_clear_uniforms(&gl, &clear_program, &clear_glsl.vertex.reflection_map);
+        let clear_program = create_shader_program(
+            &gl,
+            clear_slots::VERTEX_SOURCE,
+            clear_slots::FRAGMENT_SOURCE,
+        );
+
+        let strip_uniforms = get_strip_uniforms(&gl, &strip_program);
+        let clear_uniforms = get_clear_uniforms(&gl, &clear_program);
 
         let resources = create_webgl_resources(&gl, slot_count);
 
@@ -546,17 +542,12 @@ fn create_shader_program(
     program
 }
 
-/// Get the  uniform locations for the strip program
-fn get_strip_uniforms(
-    gl: &WebGl2RenderingContext,
-    program: &WebGlProgram,
-    vertex_reflection: &ReflectionMap<&'static str>,
-    fragment_reflection: &ReflectionMap<&'static str>,
-) -> StripUniforms {
-    let config_vs_name = vertex_reflection.uniforms.get("config").unwrap();
+/// Get the  uniform locations for the `render_strips` program.
+fn get_strip_uniforms(gl: &WebGl2RenderingContext, program: &WebGlProgram) -> StripUniforms {
+    let config_vs_name = render_strips::vertex::CONFIG;
     let config_vs_block_index = gl.get_uniform_block_index(program, config_vs_name);
 
-    let config_fs_name = fragment_reflection.uniforms.get("config").unwrap();
+    let config_fs_name = render_strips::fragment::CONFIG;
     let config_fs_block_index = gl.get_uniform_block_index(program, config_fs_name);
 
     debug_assert_ne!(
@@ -575,14 +566,8 @@ fn get_strip_uniforms(
     gl.uniform_block_binding(program, config_fs_block_index, 0);
 
     // Get texture uniform locations.
-    let alphas_texture_name = fragment_reflection
-        .texture_mapping
-        .get("alphas_texture")
-        .unwrap();
-    let clip_input_texture_name = fragment_reflection
-        .texture_mapping
-        .get("clip_input_texture")
-        .unwrap();
+    let alphas_texture_name = render_strips::fragment::ALPHAS_TEXTURE;
+    let clip_input_texture_name = render_strips::fragment::CLIP_INPUT_TEXTURE;
 
     StripUniforms {
         config_vs_block_index,
@@ -596,13 +581,9 @@ fn get_strip_uniforms(
     }
 }
 
-/// Get the uniform locations for the clear program.
-fn get_clear_uniforms(
-    gl: &WebGl2RenderingContext,
-    program: &WebGlProgram,
-    vertex_reflection: &ReflectionMap<&'static str>,
-) -> ClearUniforms {
-    let config_name = vertex_reflection.uniforms.get("config").unwrap();
+/// Get the uniform locations for the `clear_slots` program.
+fn get_clear_uniforms(gl: &WebGl2RenderingContext, program: &WebGlProgram) -> ClearUniforms {
+    let config_name = clear_slots::vertex::CONFIG;
     let config_block_index = gl.get_uniform_block_index(program, config_name);
 
     debug_assert_ne!(

sparse_strips/vello_sparse_shaders/build.rs

@@ -17,7 +17,6 @@ mod types;
 
 use compile::compile_wgsl_shader;
 
-// TODO: Format the generated code via `rustfmt`.
 // TODO: Use `quote` instead of string concatenation to generate code.
 fn main() {
     // Rerun build if the shaders directory changes
@@ -63,48 +62,18 @@ fn generate_compiled_shaders_module(buf: &mut String, shader_infos: &[(String, S
         "// Generated code by `vello_sparse_shaders` - DO NOT EDIT"
     )
     .unwrap();
-    writeln!(
-        buf,
-        "use crate::types::{{CompiledGlsl, ReflectionMap, Stage}};"
-    )
-    .unwrap();
     writeln!(
         buf,
         "/// Build time GLSL shaders derived from wgsl shaders."
     )
     .unwrap();
-    writeln!(buf, "pub mod shaders {{").unwrap();
-    writeln!(
-        buf,
-        r#"    #![allow(unused_mut, reason = "Increases code gen complexity")]"#
-    )
-    .unwrap();
-    writeln!(
-        buf,
-        "    use super::{{CompiledGlsl, ReflectionMap, Stage}};"
-    )
-    .unwrap();
-
-    // Public interface for accessing the CompiledGlsl struct per shader.
-    for (shader_name, _) in shader_infos {
-        writeln!(buf, "    /// Compiled glsl for `{shader_name}.wgsl`").unwrap();
-        writeln!(
-            buf,
-            "    pub fn {shader_name}() -> CompiledGlsl<&'static str> {{"
-        )
-        .unwrap();
-        writeln!(buf, "        {shader_name}_impl()").unwrap();
-        writeln!(buf, "    }}").unwrap();
-    }
 
     // Implementation for creating a CompiledGlsl struct per shader assuming the standard entry
     // names of `vs_main` and `fs_main`.
     for (shader_name, shader_source) in shader_infos {
         let compiled = compile_wgsl_shader(shader_source, "vs_main", "fs_main");
 
-        let generated_code = compiled.to_generated_code(&format!("{shader_name}_impl"));
+        let generated_code = compiled.to_generated_code(shader_name);
         writeln!(buf, "{generated_code}").unwrap();
     }
-
-    writeln!(buf, "}}\n").unwrap();
 }

sparse_strips/vello_sparse_shaders/src/lib.rs

@@ -4,8 +4,6 @@
 //! This is a utility library to help integrate `vello_hybrid` WebGPU wgsl shaders into glsl.
 
 mod compile;
-pub mod types;
-
-extern crate alloc;
+mod types;
 
 include!(concat!(env!("OUT_DIR"), "/compiled_shaders.rs"));