shaders can be either a path or a string

librashader-capi/src/ctypes.rs

@@ -181,6 +181,7 @@ pub(crate) use config_struct;
 pub(crate) use config_version_set;
 
 #[doc(hidden)]
+#[deny(deprecated)]
 #[deprecated = "Forward declarations for cbindgen, do not use."]
 mod __cbindgen_opaque_forward_declarations {
     macro_rules! typedef_struct {
@@ -188,6 +189,7 @@ mod __cbindgen_opaque_forward_declarations {
             $($(#[$($attrss)*])*
                 #[allow(unused)]
                 #[doc(hidden)]
+                #[deny(deprecated)]
                 #[deprecated]
                 pub struct $name;
             )*

librashader-capi/src/lib.rs

@@ -66,6 +66,7 @@
 #![allow(non_camel_case_types)]
 #![feature(try_blocks)]
 #![deny(unsafe_op_in_unsafe_fn)]
+#![deny(deprecated)]
 
 extern crate alloc;
 

librashader-runtime-d3d11/src/filter_chain.rs

@@ -75,34 +75,28 @@ pub(crate) struct FilterCommon {
     pub(crate) draw_quad: DrawQuad,
 }
 
-mod compile {
+type ShaderPassMeta =
-    use super::*;
+    ShaderPassArtifact<impl CompileReflectShader<HLSL, SpirvCompilation, SpirvCross> + Send>;
-    pub type ShaderPassMeta =
+fn compile_passes(
-        ShaderPassArtifact<impl CompileReflectShader<HLSL, SpirvCompilation, SpirvCross> + Send>;
+    shaders: Vec<ShaderPassConfig>,
+    textures: &[TextureConfig],
+    disable_cache: bool,
+) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
+    let (passes, semantics) = if !disable_cache {
+        HLSL::compile_preset_passes::<
+            CachedCompilation<SpirvCompilation>,
+            SpirvCross,
+            FilterChainError,
+        >(shaders, &textures)?
+    } else {
+        HLSL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
+            shaders, &textures,
+        )?
+    };
 
-    pub fn compile_passes(
+    Ok((passes, semantics))
-        shaders: Vec<ShaderPassConfig>,
-        textures: &[TextureConfig],
-        disable_cache: bool,
-    ) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
-        let (passes, semantics) = if !disable_cache {
-            HLSL::compile_preset_passes::<
-                CachedCompilation<SpirvCompilation>,
-                SpirvCross,
-                FilterChainError,
-            >(shaders, &textures)?
-        } else {
-            HLSL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
-                shaders, &textures,
-            )?
-        };
-
-        Ok((passes, semantics))
-    }
 }
 
-use compile::{compile_passes, ShaderPassMeta};
-
 impl FilterChainD3D11 {
     /// Load the shader preset at the given path into a filter chain.
     pub unsafe fn load_from_path(

librashader-runtime-d3d12/src/filter_chain.rs

@@ -146,56 +146,48 @@ impl Drop for FrameResiduals {
     }
 }
 
-mod compile {
+type DxilShaderPassMeta =
-    use super::*;
+    ShaderPassArtifact<impl CompileReflectShader<DXIL, SpirvCompilation, SpirvCross> + Send>;
-    pub type DxilShaderPassMeta =
+fn compile_passes_dxil(
-        ShaderPassArtifact<impl CompileReflectShader<DXIL, SpirvCompilation, SpirvCross> + Send>;
+    shaders: Vec<ShaderPassConfig>,
+    textures: &[TextureConfig],
+    disable_cache: bool,
+) -> Result<(Vec<DxilShaderPassMeta>, ShaderSemantics), FilterChainError> {
+    let (passes, semantics) = if !disable_cache {
+        DXIL::compile_preset_passes::<
+            CachedCompilation<SpirvCompilation>,
+            SpirvCross,
+            FilterChainError,
+        >(shaders, &textures)?
+    } else {
+        DXIL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
+            shaders, &textures,
+        )?
+    };
 
-    pub fn compile_passes_dxil(
+    Ok((passes, semantics))
-        shaders: Vec<ShaderPassConfig>,
-        textures: &[TextureConfig],
-        disable_cache: bool,
-    ) -> Result<(Vec<DxilShaderPassMeta>, ShaderSemantics), FilterChainError> {
-        let (passes, semantics) = if !disable_cache {
-            DXIL::compile_preset_passes::<
-                CachedCompilation<SpirvCompilation>,
-                SpirvCross,
-                FilterChainError,
-            >(shaders, &textures)?
-        } else {
-            DXIL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
-                shaders, &textures,
-            )?
-        };
-
-        Ok((passes, semantics))
-    }
-
-    pub type HlslShaderPassMeta =
-        ShaderPassArtifact<impl CompileReflectShader<HLSL, SpirvCompilation, SpirvCross> + Send>;
-
-    pub fn compile_passes_hlsl(
-        shaders: Vec<ShaderPassConfig>,
-        textures: &[TextureConfig],
-        disable_cache: bool,
-    ) -> Result<(Vec<HlslShaderPassMeta>, ShaderSemantics), FilterChainError> {
-        let (passes, semantics) = if !disable_cache {
-            HLSL::compile_preset_passes::<
-                CachedCompilation<SpirvCompilation>,
-                SpirvCross,
-                FilterChainError,
-            >(shaders, &textures)?
-        } else {
-            HLSL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
-                shaders, &textures,
-            )?
-        };
-
-        Ok((passes, semantics))
-    }
 }
+type HlslShaderPassMeta =
+    ShaderPassArtifact<impl CompileReflectShader<HLSL, SpirvCompilation, SpirvCross> + Send>;
+fn compile_passes_hlsl(
+    shaders: Vec<ShaderPassConfig>,
+    textures: &[TextureConfig],
+    disable_cache: bool,
+) -> Result<(Vec<HlslShaderPassMeta>, ShaderSemantics), FilterChainError> {
+    let (passes, semantics) = if !disable_cache {
+        HLSL::compile_preset_passes::<
+            CachedCompilation<SpirvCompilation>,
+            SpirvCross,
+            FilterChainError,
+        >(shaders, &textures)?
+    } else {
+        HLSL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
+            shaders, &textures,
+        )?
+    };
 
-use compile::{compile_passes_dxil, compile_passes_hlsl, DxilShaderPassMeta, HlslShaderPassMeta};
+    Ok((passes, semantics))
+}
 
 impl FilterChainD3D12 {
     /// Load the shader preset at the given path into a filter chain.

librashader-runtime-d3d9/src/filter_chain.rs

@@ -63,34 +63,29 @@ pub struct FilterChainD3D9 {
     default_options: FrameOptionsD3D9,
 }
 
-mod compile {
+type ShaderPassMeta =
-    use super::*;
+    ShaderPassArtifact<impl CompileReflectShader<HLSL, SpirvCompilation, SpirvCross> + Send>;
-    pub type ShaderPassMeta =
-        ShaderPassArtifact<impl CompileReflectShader<HLSL, SpirvCompilation, SpirvCross> + Send>;
 
-    pub fn compile_passes(
+fn compile_passes(
-        shaders: Vec<ShaderPassConfig>,
+    shaders: Vec<ShaderPassConfig>,
-        textures: &[TextureConfig],
+    textures: &[TextureConfig],
-        disable_cache: bool,
+    disable_cache: bool,
-    ) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
+) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
-        let (passes, semantics) = if !disable_cache {
+    let (passes, semantics) = if !disable_cache {
-            HLSL::compile_preset_passes::<
+        HLSL::compile_preset_passes::<
-                CachedCompilation<SpirvCompilation>,
+            CachedCompilation<SpirvCompilation>,
-                SpirvCross,
+            SpirvCross,
-                FilterChainError,
+            FilterChainError,
-            >(shaders, &textures)?
+        >(shaders, &textures)?
-        } else {
+    } else {
-            HLSL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
+        HLSL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
-                shaders, &textures,
+            shaders, &textures,
-            )?
+        )?
-        };
+    };
 
-        Ok((passes, semantics))
+    Ok((passes, semantics))
-    }
 }
 
-use compile::{compile_passes, ShaderPassMeta};
-
 impl FilterChainD3D9 {
     fn init_passes(
         device: &IDirect3DDevice9,

librashader-runtime-gl/src/filter_chain/filter_impl.rs

@@ -92,34 +92,28 @@ impl<T: GLInterface> FilterChainImpl<T> {
     }
 }
 
-mod compile {
+type ShaderPassMeta =
-    use super::*;
+    ShaderPassArtifact<impl CompileReflectShader<GLSL, SpirvCompilation, SpirvCross>>;
-    pub type ShaderPassMeta =
+fn compile_passes(
-        ShaderPassArtifact<impl CompileReflectShader<GLSL, SpirvCompilation, SpirvCross>>;
+    shaders: Vec<ShaderPassConfig>,
+    textures: &[TextureConfig],
+    disable_cache: bool,
+) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
+    let (passes, semantics) = if !disable_cache {
+        GLSL::compile_preset_passes::<
+            CachedCompilation<SpirvCompilation>,
+            SpirvCross,
+            FilterChainError,
+        >(shaders, &textures)?
+    } else {
+        GLSL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
+            shaders, &textures,
+        )?
+    };
 
-    pub fn compile_passes(
+    Ok((passes, semantics))
-        shaders: Vec<ShaderPassConfig>,
-        textures: &[TextureConfig],
-        disable_cache: bool,
-    ) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
-        let (passes, semantics) = if !disable_cache {
-            GLSL::compile_preset_passes::<
-                CachedCompilation<SpirvCompilation>,
-                SpirvCross,
-                FilterChainError,
-            >(shaders, &textures)?
-        } else {
-            GLSL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
-                shaders, &textures,
-            )?
-        };
-
-        Ok((passes, semantics))
-    }
 }
 
-use compile::{compile_passes, ShaderPassMeta};
-
 impl<T: GLInterface> FilterChainImpl<T> {
     /// Load a filter chain from a pre-parsed `ShaderPreset`.
     pub(crate) unsafe fn load_from_preset(

librashader-runtime-gl/src/gl/gl46/framebuffer.rs

@@ -187,4 +187,4 @@ impl FramebufferInterface for Gl46Framebuffer {
         }
         Ok(())
     }
-}
+}

librashader-runtime-mtl/src/filter_chain.rs

@@ -40,25 +40,19 @@ use std::collections::VecDeque;
 use std::fmt::{Debug, Formatter};
 use std::path::Path;
 
-mod compile {
+type ShaderPassMeta =
-    use super::*;
+    ShaderPassArtifact<impl CompileReflectShader<MSL, SpirvCompilation, SpirvCross> + Send>;
-    pub type ShaderPassMeta =
+fn compile_passes(
-        ShaderPassArtifact<impl CompileReflectShader<MSL, SpirvCompilation, SpirvCross> + Send>;
+    shaders: Vec<ShaderPassConfig>,
-
+    textures: &[TextureConfig],
-    pub fn compile_passes(
+) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
-        shaders: Vec<ShaderPassConfig>,
+    let (passes, semantics) =
-        textures: &[TextureConfig],
+        MSL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
-    ) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
+            shaders, &textures,
-        let (passes, semantics) =
+        )?;
-            MSL::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
+    Ok((passes, semantics))
-                shaders, &textures,
-            )?;
-        Ok((passes, semantics))
-    }
 }
 
-use compile::{compile_passes, ShaderPassMeta};
-
 /// A Metal filter chain.
 pub struct FilterChainMetal {
     pub(crate) common: FilterCommon,

librashader-runtime-vk/src/filter_chain.rs

@@ -209,34 +209,28 @@ impl Drop for FrameResiduals {
     }
 }
 
-mod compile {
+type ShaderPassMeta =
-    use super::*;
+    ShaderPassArtifact<impl CompileReflectShader<SPIRV, SpirvCompilation, SpirvCross> + Send>;
-    pub type ShaderPassMeta =
+fn compile_passes(
-        ShaderPassArtifact<impl CompileReflectShader<SPIRV, SpirvCompilation, SpirvCross> + Send>;
+    shaders: Vec<ShaderPassConfig>,
+    textures: &[TextureConfig],
+    disable_cache: bool,
+) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
+    let (passes, semantics) = if !disable_cache {
+        SPIRV::compile_preset_passes::<
+            CachedCompilation<SpirvCompilation>,
+            SpirvCross,
+            FilterChainError,
+        >(shaders, &textures)?
+    } else {
+        SPIRV::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
+            shaders, &textures,
+        )?
+    };
 
-    pub fn compile_passes(
+    Ok((passes, semantics))
-        shaders: Vec<ShaderPassConfig>,
-        textures: &[TextureConfig],
-        disable_cache: bool,
-    ) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
-        let (passes, semantics) = if !disable_cache {
-            SPIRV::compile_preset_passes::<
-                CachedCompilation<SpirvCompilation>,
-                SpirvCross,
-                FilterChainError,
-            >(shaders, &textures)?
-        } else {
-            SPIRV::compile_preset_passes::<SpirvCompilation, SpirvCross, FilterChainError>(
-                shaders, &textures,
-            )?
-        };
-
-        Ok((passes, semantics))
-    }
 }
 
-use compile::{compile_passes, ShaderPassMeta};
-
 impl FilterChainVulkan {
     /// Load the shader preset at the given path into a filter chain.
     pub unsafe fn load_from_path<V, E>(

librashader-runtime-wgpu/Cargo.toml

@@ -21,7 +21,7 @@ librashader-reflect = { path = "../librashader-reflect", version = "0.2.7", feat
 librashader-runtime = { path = "../librashader-runtime" , version = "0.2.7" }
 
 wgpu = { version = "0.20.0", default-features = false, features = ["wgsl"] }
-image = "0.25.1"
+image = "0.24.7"
 thiserror = "1.0.50"
 bytemuck = { version = "1.14.0", features = ["derive"] }
 array-concat = "0.5.2"

librashader-runtime-wgpu/src/filter_chain.rs

@@ -38,25 +38,19 @@ use crate::options::{FilterChainOptionsWgpu, FrameOptionsWgpu};
 use crate::samplers::SamplerSet;
 use crate::texture::{InputImage, OwnedImage};
 
-mod compile {
+type ShaderPassMeta =
-    use super::*;
+    ShaderPassArtifact<impl CompileReflectShader<WGSL, SpirvCompilation, Naga> + Send>;
-    pub type ShaderPassMeta =
+fn compile_passes(
-        ShaderPassArtifact<impl CompileReflectShader<WGSL, SpirvCompilation, Naga> + Send>;
+    shaders: Vec<ShaderPassConfig>,
-
+    textures: &[TextureConfig],
-    pub fn compile_passes(
+) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
-        shaders: Vec<ShaderPassConfig>,
+    let (passes, semantics) =
-        textures: &[TextureConfig],
+        WGSL::compile_preset_passes::<SpirvCompilation, Naga, FilterChainError>(
-    ) -> Result<(Vec<ShaderPassMeta>, ShaderSemantics), FilterChainError> {
+            shaders, &textures,
-        let (passes, semantics) =
+        )?;
-            WGSL::compile_preset_passes::<SpirvCompilation, Naga, FilterChainError>(
+    Ok((passes, semantics))
-                shaders, &textures,
-            )?;
-        Ok((passes, semantics))
-    }
 }
 
-use compile::{compile_passes, ShaderPassMeta};
-
 /// A wgpu filter chain.
 pub struct FilterChainWgpu {
     pub(crate) common: FilterCommon,

librashader-runtime/Cargo.toml

@@ -23,7 +23,7 @@ array-concat = "0.5.2"
 tinymap = "0.4.0"
 
 [dependencies.image]
-version = "0.25.1"
+version = "0.24.5"
 features = [
     "gif", "jpeg", "png",
     "tga", "pnm", "tiff",

librashader-runtime/src/scaling.rs

@@ -5,27 +5,24 @@ use librashader_presets::{Scale2D, ScaleFactor, ScaleType, Scaling};
 use num_traits::AsPrimitive;
 use std::ops::Mul;
 
-pub const MAX_TEXEL_SIZE: f32 = 16384f32;
-
 /// Trait for size scaling relative to the viewport.
 pub trait ViewportSize<T>
 where
-    T: Mul<ScaleFactor, Output = f32> + Copy + Ord + 'static,
+    T: Mul<ScaleFactor, Output = f32> + Copy + 'static,
     f32: AsPrimitive<T>,
 {
     /// Produce a `Size<T>` scaled with the input scaling options.
-    /// The size will at minimum be 1x1, and at a maximum 16384x16384.
     fn scale_viewport(self, scaling: Scale2D, viewport: Size<T>, original: Size<T>) -> Size<T>;
 }
 
 impl<T> ViewportSize<T> for Size<T>
 where
-    T: Mul<ScaleFactor, Output = f32> + Copy + Ord + 'static,
+    T: Mul<ScaleFactor, Output = f32> + Copy + 'static,
     f32: AsPrimitive<T>,
 {
     fn scale_viewport(self, scaling: Scale2D, viewport: Size<T>, original: Size<T>) -> Size<T>
     where
-        T: Mul<ScaleFactor, Output = f32> + Copy + Ord + 'static,
+        T: Mul<ScaleFactor, Output = f32> + Copy + 'static,
         f32: AsPrimitive<T>,
     {
         scaling::scale(scaling, self, viewport, original)
@@ -38,7 +35,6 @@ pub trait MipmapSize<T> {
     fn calculate_miplevels(self) -> T;
 
     /// Scale the size according to the given mipmap level.
-    /// The size will at minimum be 1x1, and at a maximum 16384x16384.
     fn scale_mipmap(self, miplevel: T) -> Size<T>;
 }
 
@@ -63,7 +59,7 @@ impl MipmapSize<u32> for Size<u32> {
 
 fn scale<T>(scaling: Scale2D, source: Size<T>, viewport: Size<T>, original: Size<T>) -> Size<T>
 where
-    T: Mul<ScaleFactor, Output = f32> + Copy + Ord + 'static,
+    T: Mul<ScaleFactor, Output = f32> + Copy + 'static,
     f32: AsPrimitive<T>,
 {
     let width = match scaling.x {
@@ -105,14 +101,8 @@ where
     };
 
     Size {
-        width: std::cmp::min(
+        width: width.round().as_(),
-            std::cmp::max(width.round().as_(), 1f32.as_()),
+        height: height.round().as_(),
-            MAX_TEXEL_SIZE.as_(),
-        ),
-        height: std::cmp::min(
-            std::cmp::max(height.round().as_(), 1f32.as_()),
-            MAX_TEXEL_SIZE.as_(),
-        ),
     }
 }