Release v0.9.6

Author: Soddentrough

.github/workflows/macos.yml

@@ -69,14 +69,24 @@ jobs:
               <string>APPL</string>
               <key>LSMinimumSystemVersion</key>
               <string>10.15</string>
+              <key>NSHighResolutionCapable</key>
+              <true/>
+              <key>LSApplicationCategoryType</key>
+              <string>public.app-category.music</string>
+              <key>NSMicrophoneUsageDescription</key>
+              <string>RustTracker needs microphone access to visualize live audio input.</string>
           </dict>
           </plist>
           EOF
           
-          # Copy binary and bundle libraries
+          # Copy binary, soundfont asset, and bundle libraries
           cp target/release/rusttracker RustTracker.app/Contents/MacOS/
+          cp assets/soundfont.sf2 RustTracker.app/Contents/Resources/
           dylibbundler -od -b -x RustTracker.app/Contents/MacOS/rusttracker -d RustTracker.app/Contents/Frameworks/ -p @executable_path/../Frameworks/
           
+          # Ad-hoc codesign the entire bundle recursively to satisfy security requirements (especially Apple Silicon)
+          codesign --force --deep --sign - RustTracker.app
+          
       - name: Create DMG
         run: |
           create-dmg \

.gitignore

@@ -48,3 +48,5 @@ scratch/
 scratch_bitstream/target/
 scratch_bitstream_windows/target/
 check_shader
+/test.rs
+/test_*

Cargo.lock

@@ -1,10 +1,10 @@
 [package]
 name = "rusttracker"
-version = "0.9.5"
+version = "0.9.6"
 edition = "2024"
 default-run = "rusttracker"
 description = "High-Performance Vulkan Tracker Module Visualizer"
-license = "MIT"
+license = "GPL-3.0-or-later"
 
 [package.metadata.generate-rpm]
 assets = [
@@ -59,3 +59,7 @@ winres = "0.1.12"
 
 [target."cfg(windows)".dependencies]
 windows = { version = "0.62.2", features = ["Win32_System_Com", "Win32_Media_Audio", "Win32_Foundation", "Win32_System_Threading", "Win32_System_Pipes"] }
+
+[target."cfg(target_os = \"macos\")".dependencies]
+objc2 = "0.6.4"
+objc2-core-audio = "0.3.2"

Cargo.toml

@@ -90,3 +90,7 @@ cargo deb
 * `spectrum-analyzer` - Fast Fourier Transforms that make the pretty things react to the loud things
 * `crossbeam-channel` - Lock-free concurrency because threads should get along
 * `openmpt` - Tracker module decoding for that sweet, sweet nostalgia
+
+## License
+
+This project is licensed under the [GNU General Public License v3.0](LICENSE) (GPLv3).

LICENSE

@@ -1384,16 +1384,39 @@ pub fn load_audio_source(file_path: &str) -> Result<Box<dyn AudioSource>> {
 
     // 3. Try MIDI
     if ext == "mid" || ext == "midi" {
-        // Look for soundfont in project dir, then fallback
-        let sf_path = if std::path::Path::new("assets/soundfont.sf2").exists() {
-            "assets/soundfont.sf2"
-        } else {
-            "soundfont.sf2" // User must provide it in the working dir if not in assets
-        };
-        if let Ok(source) = MidiSource::new(file_path, sf_path, 48000) {
+        // Look for soundfont in project dir, then fallback to executable-relative paths and macOS Resources bundle
+        let mut sf_path = "assets/soundfont.sf2".to_string();
+        if !std::path::Path::new(&sf_path).exists() {
+            if std::path::Path::new("soundfont.sf2").exists() {
+                sf_path = "soundfont.sf2".to_string();
+            } else if let Ok(exe_path) = std::env::current_exe() {
+                if let Some(exe_dir) = exe_path.parent() {
+                    let test_path = exe_dir.join("assets/soundfont.sf2");
+                    if test_path.exists() {
+                        sf_path = test_path.to_string_lossy().into_owned();
+                    } else {
+                        let test_path = exe_dir.join("soundfont.sf2");
+                        if test_path.exists() {
+                            sf_path = test_path.to_string_lossy().into_owned();
+                        } else {
+                            let test_path = exe_dir.join("../Resources/soundfont.sf2");
+                            if test_path.exists() {
+                                sf_path = test_path.to_string_lossy().into_owned();
+                            } else {
+                                let test_path = exe_dir.join("../Resources/assets/soundfont.sf2");
+                                if test_path.exists() {
+                                    sf_path = test_path.to_string_lossy().into_owned();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if let Ok(source) = MidiSource::new(file_path, &sf_path, 48000) {
             return Ok(Box::new(source));
         } else {
-            return Err(anyhow::anyhow!("Failed to parse MIDI or missing SoundFont ({}). Please place a SoundFont in assets/soundfont.sf2", sf_path));
+            return Err(anyhow::anyhow!("Failed to parse MIDI or missing SoundFont ({}). Please place a SoundFont in assets/soundfont.sf2 or bundled resources", sf_path));
         }
     }
 

README.md

@@ -1,27 +1,69 @@
+use std::path::Path;
+
 fn main() {
-    let source = std::fs::read_to_string("src/shaders/vis_3drain.wgsl").unwrap();
-    // we need to include common
-    let common = "struct VertexOutput { @builtin(position) clip_position: vec4<f32>, @location(0) uv: vec2<f32>, }; @vertex fn vs_main(@builtin(vertex_index) in_vertex_index: u32) -> VertexOutput { var out: VertexOutput; return out; } struct AudioUniforms { spectrum: array<vec4<f32>, 256>, fire_heat: array<vec4<f32>, 256>, channels: array<vec4<f32>, 8>, channel_peaks: array<vec4<f32>, 8>, spatial_channels: array<vec4<f32>, 4>, display_order: array<vec4<u32>, 4>, num_channels: u32, mode: u32, time: f32, duration: f32, smooth_time: f32, heatmap_row: u32, fft_channels: u32, num_spatial_channels: u32, ui_meters_rect: vec4<f32>, ui_heatmap_rect: vec4<f32>, ui_fire_rect: vec4<f32>, waveform_resolution: u32, waveform_history_size: u32, _pad0: u32, _pad1: u32, };";
-    let full_source = source.replace("// INCLUDE: common", common);
-    let mut frontend = naga::front::wgsl::Frontend::new();
-    match frontend.parse(&full_source) {
-        Ok(module) => {
-            let mut validator = naga::valid::Validator::new(
-                naga::valid::ValidationFlags::all(),
-                naga::valid::Capabilities::all(),
-            );
-            match validator.validate(&module) {
-                Ok(_) => println!("WGSL Validated Successfully"),
-                Err(e) => {
-                    eprintln!("Validation error: {:?}", e);
-                    std::process::exit(1);
+    let common = std::fs::read_to_string("src/shaders/_common.wgsl")
+        .expect("Failed to read _common.wgsl");
+    let glyph_font = std::fs::read_to_string("src/shaders/_glyph_font.wgsl")
+        .expect("Failed to read _glyph_font.wgsl");
+
+    let shader_dir = Path::new("src/shaders");
+    let entries = std::fs::read_dir(shader_dir).expect("Failed to read src/shaders directory");
+
+    let mut failed = false;
+    let mut validated_count = 0;
+
+    for entry in entries {
+        let entry = entry.expect("Failed to read entry");
+        let path = entry.path();
+        if path.is_file() {
+            if let Some(ext) = path.extension() {
+                if ext == "wgsl" {
+                    let filename = path.file_name().unwrap().to_string_lossy().into_owned();
+                    // Skip the helper header files themselves as they are incomplete standalone WGSL
+                    if filename.starts_with('_') {
+                        continue;
+                    }
+
+                    let source = std::fs::read_to_string(&path)
+                        .unwrap_or_else(|_| panic!("Failed to read shader {:?}", path));
+                    
+                    let full_source = source
+                        .replace("// INCLUDE: common", &common)
+                        .replace("// INCLUDE: glyph_font", &glyph_font);
+
+                    let mut frontend = naga::front::wgsl::Frontend::new();
+                    match frontend.parse(&full_source) {
+                        Ok(module) => {
+                            let mut validator = naga::valid::Validator::new(
+                                naga::valid::ValidationFlags::all(),
+                                naga::valid::Capabilities::all(),
+                            );
+                            match validator.validate(&module) {
+                                Ok(_) => {
+                                    println!("Successfully validated: {}", filename);
+                                    validated_count += 1;
+                                }
+                                Err(e) => {
+                                    eprintln!("Validation error in {}: {:?}", filename, e);
+                                    failed = true;
+                                }
+                            }
+                        }
+                        Err(e) => {
+                            let err_str = e.emit_to_string_with_path(&full_source, &filename);
+                            eprintln!("Parse error in {}:\n{}", filename, err_str);
+                            failed = true;
+                        }
+                    }
                 }
             }
-        },
-        Err(e) => {
-            let err_str = e.emit_to_string_with_path(&full_source, "vis_3drain.wgsl");
-            eprintln!("{}", err_str);
-            std::process::exit(1);
         }
     }
+
+    if failed {
+        eprintln!("\nSome shaders failed validation.");
+        std::process::exit(1);
+    } else {
+        println!("\nAll {} shaders validated successfully!", validated_count);
+    }
 }