WIP fixing uniforms layout, Fix some codegen formatting

Still crashing frequently/unpredicatbly when switching between some
shaders. Still need to fix name order of input uniforms.

assets/isf/Test-Audio.fs

@@ -45,4 +45,4 @@ void main() {
 	vec4		waveAdd = (1.0 - smoothstep(0.0, waveSize, abs(wave - loc.x)));
 	waveAdd.a = 1.0;
 	gl_FragColor = waveAdd;
-}
+}

examples/isf/isf_demo.rs

@@ -151,7 +151,7 @@ fn update(app: &App, model: &mut Model, update: Update) {
         let mut encoder = device.create_command_encoder(&desc);
         isf.pipeline
             .encode_update(device, &mut encoder, &images_dir, touched_shaders);
-        shader_window.swap_chain_queue().submit(&[encoder.finish()]);
+        shader_window.swap_chain_queue().submit(Some(encoder.finish()));
         isf.time.time = update.since_start.secs() as _;
         isf.time.time_delta = update.since_last.secs() as _;
     }
@@ -391,7 +391,7 @@ fn create_isf_state(shader_window: &Window, fs_path: PathBuf, images_path: &Path
         dst_sample_count,
         images_path,
     );
-    shader_window.swap_chain_queue().submit(&[encoder.finish()]);
+    shader_window.swap_chain_queue().submit(Some(encoder.finish()));
     let time = Default::default();
     IsfState {
         path: fs_path,

nannou_isf/src/lib.rs

@@ -13,26 +13,61 @@ pub fn isf_from_shader_path(path: &Path) -> Result<isf::Isf, isf::ParseError> {
     isf::parse(&glsl_string)
 }
 
+/// The associated uniform type for the given input type.
+///
+/// Returns `None` for variants that are not stored within the uniform buffer.
+pub fn input_type_uniform_type(ty: &isf::InputType) -> Option<&'static str> {
+    let s = match *ty {
+        isf::InputType::Event | isf::InputType::Bool(_) => "bool",
+        isf::InputType::Long(_) => "int",
+        isf::InputType::Float(_) => "float",
+        isf::InputType::Point2d(_) => "vec2",
+        isf::InputType::Color(_) => "vec4",
+        isf::InputType::Image
+        | isf::InputType::Audio(_)
+        | isf::InputType::AudioFft(_) => return None,
+    };
+    Some(s)
+}
+
+/// The size in bytes of the input type when laid out within the uniform struct.
+///
+/// Returns `None` for variants that are not stored within the uniform buffer.
+pub fn input_type_uniform_size_bytes(ty: &isf::InputType) -> Option<usize> {
+    let size = match *ty {
+        isf::InputType::Color(_) => 4 * 4,
+        isf::InputType::Point2d(_) => 2 * 2,
+        isf::InputType::Long(_)
+        | isf::InputType::Float(_)
+        | isf::InputType::Bool(_)
+        | isf::InputType::Event { .. } => 1 * 4,
+        isf::InputType::Image
+        | isf::InputType::Audio(_)
+        | isf::InputType::AudioFft(_) => return None,
+    };
+    Some(size)
+}
+
 /// Generate the necessary GLSL declarations from the given ISF to be prefixed to the GLSL string
 /// from which the ISF was parsed.
 ///
 /// This string should be inserted directly after the version preprocessor.
 pub fn glsl_string_from_isf(isf: &isf::Isf) -> String {
     // The normalised coords passed through from the vertex shader.
     let frag_norm_coord_str = "
-        layout(location = 0) in vec2 isf_FragNormCoord;
+layout(location = 0) in vec2 isf_FragNormCoord;\n\
     ";
 
     // Create the `IsfData` uniform buffer with time, date, etc.
     let isf_data_str = "
-        layout(set = 0, binding = 0) uniform IsfData {
-            int PASSINDEX;
-            vec2 RENDERSIZE;
-            float TIME;
-            float TIMEDELTA;
-            vec4 DATE;
-            int FRAMEINDEX;
-        };
+layout(set = 0, binding = 0) uniform IsfData {
+    vec4 DATE;
+    vec2 RENDERSIZE;
+    float TIME;
+    float TIMEDELTA;
+    int PASSINDEX;
+    int FRAMEINDEX;
+};\n\
     ";
 
     // Create the `IsfDataInputs` uniform buffer with a field for each event, float, long, bool,
@@ -41,21 +76,23 @@ pub fn glsl_string_from_isf(isf: &isf::Isf) -> String {
         false => None,
         true => {
             let mut isf_data_input_string = "
-                layout(set = 1, binding = 0) uniform IsfDataInputs {\n
+layout(set = 1, binding = 0) uniform IsfDataInputs {\n\
             "
             .to_string();
-            for input in &isf.inputs {
-                let ty_str = match input.ty {
-                    isf::InputType::Event | isf::InputType::Bool(_) => "bool",
-                    isf::InputType::Long(_) => "int",
-                    isf::InputType::Float(_) => "float",
-                    isf::InputType::Point2d(_) => "vec2",
-                    isf::InputType::Color(_) => "vec4",
-                    isf::InputType::Image
-                    | isf::InputType::Audio(_)
-                    | isf::InputType::AudioFft(_) => continue,
+
+            // Input uniforms should be sorted by name and input type uniform size.
+
+            // Must layout from largest to smallest types to avoid padding holes.
+            let b16 = isf.inputs.iter().filter(|i| input_type_uniform_size_bytes(&i.ty) == Some(16));
+            let b8 = isf.inputs.iter().filter(|i| input_type_uniform_size_bytes(&i.ty) == Some(8));
+            let b4 = isf.inputs.iter().filter(|i| input_type_uniform_size_bytes(&i.ty) == Some(4));
+            for input in b16.chain(b8).chain(b4) {
+                dbg!(&input.ty);
+                let ty_str = match input_type_uniform_type(&input.ty) {
+                    Some(s) => s,
+                    None => continue,
                 };
-                isf_data_input_string.push_str(&format!("{} {};\n", ty_str, input.name));
+                isf_data_input_string.push_str(&format!("    {} {};\n", ty_str, input.name));
             }
             isf_data_input_string.push_str("};\n");
             Some(isf_data_input_string)
@@ -64,7 +101,7 @@ pub fn glsl_string_from_isf(isf: &isf::Isf) -> String {
 
     // Create the `img_sampler` binding, used for sampling all input images.
     let img_sampler_str = "
-        layout(set = 2, binding = 0) uniform sampler img_sampler;
+layout(set = 2, binding = 0) uniform sampler img_sampler;\n\
     ";
 
     // Create the textures for the "IMPORTED" images.
@@ -111,32 +148,32 @@ pub fn glsl_string_from_isf(isf: &isf::Isf) -> String {
 
     // Image functions.
     let img_fns_str = "
-        // ISF provided short-hand for retrieving image size.
-        ivec2 IMG_SIZE(texture2D img) {
-            return textureSize(sampler2D(img, img_sampler), 0);
-        }
+// ISF provided short-hand for retrieving image size.
+ivec2 IMG_SIZE(texture2D img) {
+    return textureSize(sampler2D(img, img_sampler), 0);
+}
 
-        // ISF provided short-hand for retrieving image color.
-        vec4 IMG_NORM_PIXEL(texture2D img, vec2 norm_px_coord) {
-            return texture(sampler2D(img, img_sampler), norm_px_coord);
-        }
+// ISF provided short-hand for retrieving image color.
+vec4 IMG_NORM_PIXEL(texture2D img, vec2 norm_px_coord) {
+    return texture(sampler2D(img, img_sampler), norm_px_coord);
+}
 
-        // ISF provided short-hand for retrieving image color.
-        vec4 IMG_PIXEL(texture2D img, vec2 px_coord) {
-            ivec2 s = IMG_SIZE(img);
-            vec2 norm_px_coord = vec2(px_coord.x / float(s.x), px_coord.y / float(s.y));
-            return IMG_NORM_PIXEL(img, px_coord);
-        }
+// ISF provided short-hand for retrieving image color.
+vec4 IMG_PIXEL(texture2D img, vec2 px_coord) {
+    ivec2 s = IMG_SIZE(img);
+    vec2 norm_px_coord = vec2(px_coord.x / float(s.x), px_coord.y / float(s.y));
+    return IMG_NORM_PIXEL(img, px_coord);
+}
 
-        // ISF provided short-hand for retrieving image color.
-        vec4 IMG_THIS_NORM_PIXEL(texture2D img) {
-            return IMG_NORM_PIXEL(img, isf_FragNormCoord);
-        }
+// ISF provided short-hand for retrieving image color.
+vec4 IMG_THIS_NORM_PIXEL(texture2D img) {
+    return IMG_NORM_PIXEL(img, isf_FragNormCoord);
+}
 
-        // ISF provided short-hand for retrieving image color.
-        vec4 IMG_THIS_PIXEL(texture2D img) {
-            return IMG_THIS_NORM_PIXEL(img);
-        }
+// ISF provided short-hand for retrieving image color.
+vec4 IMG_THIS_PIXEL(texture2D img) {
+    return IMG_THIS_NORM_PIXEL(img);
+}
     ";
 
     // Combine all the declarations together.

nannou_isf/src/pipeline.rs

@@ -37,11 +37,11 @@ pub struct IsfPipeline {
 #[repr(C)]
 #[derive(Clone, Copy, Debug)]
 struct IsfUniforms {
-    pass_index: i32,
+    date: [f32; 4],
     render_size: [f32; 2],
     time: f32,
     time_delta: f32,
-    date: [f32; 4],
+    pass_index: i32,
     frame_index: i32,
 }
 
@@ -357,6 +357,22 @@ impl IsfInputData {
         }
     }
 
+    /// The size of this field when laid out within the dynamically sized input uniform buffer.
+    pub fn uniform_size_bytes(&self) -> Option<usize> {
+        let size = match *self {
+            IsfInputData::Color(_) => 4 * 4,
+            IsfInputData::Point2d(_) => 2 * 2,
+            IsfInputData::Long(_)
+            | IsfInputData::Float(_)
+            | IsfInputData::Bool(_)
+            | IsfInputData::Event { .. } => 1 * 4,
+            IsfInputData::Image(_)
+            | IsfInputData::Audio { .. }
+            | IsfInputData::AudioFft { .. } => return None,
+        };
+        Some(size)
+    }
+
     /// Update an existing instance ISF input data instance with the given input.
     fn update(
         &mut self,
@@ -407,6 +423,9 @@ pub fn compile_isf_shader(
         .and_then(|(old_str, isf)| {
             let isf_str = crate::glsl_string_from_isf(&isf);
             let new_str = crate::prefix_isf_glsl_str(&isf_str, old_str);
+            println!("---------- {}", path.display());
+            println!("{}", new_str);
+            println!("----------");
             let ty = hotglsl::ShaderType::Fragment;
             hotglsl::compile_str(&new_str, ty).map_err(From::from)
         });
@@ -513,11 +532,11 @@ impl IsfPipeline {
         // Prepare the uniform data.
         let [dst_tex_w, dst_tex_h] = dst_texture_size;
         let isf_uniforms = IsfUniforms {
-            pass_index: 0,
+            date: [0.0; 4],
             render_size: [dst_tex_w as f32, dst_tex_h as f32],
             time: 0.0,
             time_delta: 0.0,
-            date: [0.0; 4],
+            pass_index: 0,
             frame_index: 0,
         };
         let isf_input_uniforms = isf_inputs_to_uniform_data(&isf_data.inputs);
@@ -791,7 +810,11 @@ impl IsfPipeline {
                 let isf_input_uniforms = isf_inputs_to_uniform_data(&self.isf_data.inputs);
                 let isf_input_uniforms_bytes = isf_input_uniforms_as_bytes(&isf_input_uniforms);
                 let usage = wgpu::BufferUsage::COPY_SRC;
-                let new_buffer = device.create_buffer_with_data(&isf_input_uniforms_bytes, usage);
+                let new_buffer = device.create_buffer_init(&BufferInitDescriptor {
+                    label: Some("nannou_isf-input_uniforms"),
+                    contents: &isf_input_uniforms_bytes,
+                    usage,
+                });
                 let size = isf_input_uniforms_bytes.len() as wgpu::BufferAddress;
                 encoder.copy_buffer_to_buffer(
                     &new_buffer,
@@ -996,10 +1019,24 @@ fn sync_isf_data(
     });
 }
 
+// The order in which inputs are laid out in the uniform buffer.
+//
+// This is important to meet the conditions required by wgpu uniform layout. Specifically, 16-byte
+// types must be aligned to 16 bytes, 8-byte types must be aligned to 8-bytes, etc.
+//
+// This must match the order specified in the generated glsl shader.
+fn isf_input_uniform_layout_order(inputs: &BTreeMap<InputName, IsfInputData>) -> impl Iterator<Item = (&InputName, &IsfInputData)> {
+    let b16 = inputs.iter().filter(|(_k, v)| v.uniform_size_bytes() == Some(16));
+    let b8 = inputs.iter().filter(|(_k, v)| v.uniform_size_bytes() == Some(8));
+    let b4 = inputs.iter().filter(|(_k, v)| v.uniform_size_bytes() == Some(4));
+    b16.chain(b8).chain(b4)
+}
+
 // Encodes the ISF inputs to a slice of `u32` values, ready for uploading to the GPU.
 fn isf_inputs_to_uniform_data(inputs: &BTreeMap<InputName, IsfInputData>) -> Vec<u32> {
     let mut u32s: Vec<u32> = vec![];
-    for v in inputs.values() {
+    for (_k, v) in isf_input_uniform_layout_order(inputs) {
+        dbg!((_k, v));
         match *v {
             IsfInputData::Event { happening } => {
                 u32s.push(if happening { 1 } else { 0 });
@@ -1008,7 +1045,7 @@ fn isf_inputs_to_uniform_data(inputs: &BTreeMap<InputName, IsfInputData>) -> Vec
                 u32s.push(if b { 1 } else { 0 });
             }
             IsfInputData::Long(l) => {
-                u32s.push(unsafe { std::mem::transmute(l) });
+                u32s.push(u32::from_le_bytes(l.to_le_bytes()));
             }
             IsfInputData::Float(f) => {
                 u32s.push(f.to_bits());