Support texture compression

This uses the block_compression crate that I wrote.

It is using WGPU compute shader to compress the textures using BC7 on the fly when loading the map.

Textures using BC7 are 1/4 of the uncompressed texture size. Quality is defined by "speed" like video encoders do: the slower, the better the quality.

.cargo/config.toml

@@ -0,0 +1,3 @@
+# Steam Hardware survey: https://store.steampowered.com/hwsurvey/Steam-Hardware-Software-Survey-Welcome-to-Steam
+[target.'cfg(target_arch="x86_64")']
+rustflags = ["-C", "target-feature=+aes,+avx,+avx2,+cmpxchg16b,+fma,+sse3,+ssse3,+sse4.1,+sse4.2"]

Cargo.toml

@@ -5,6 +5,7 @@ members = ["korangar", "ragnarok_*", "korangar_*"]
 [workspace.dependencies]
 arrayvec = "0.7"
 bitflags = "2.6"
+block_compression = { version = "0.2", default-features = false }
 bumpalo = "3.16"
 bytemuck = "1.21"
 cgmath = "0.18"
@@ -52,6 +53,9 @@ walkdir = "2.5"
 wgpu = "24"
 winit = "0.30"
 
+[profile.release]
+lto = "thin"
+
 [profile.dev.build-override]
 opt-level = 3
 

korangar/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 arrayvec = { workspace = true }
+block_compression = { workspace = true, features = ["bc7", "wgpu"] }
 bumpalo = { workspace = true, features = ["allocator_api"] }
 bytemuck = { workspace = true, features = ["derive", "extern_crate_std", "min_const_generics"] }
 cgmath = { workspace = true, features = ["mint", "serde"] }

korangar/src/graphics/capabilities.rs

@@ -17,6 +17,7 @@ pub struct Capabilities {
     bindless: bool,
     multidraw_indirect: bool,
     clamp_to_border: bool,
+    texture_compression: bool,
     #[cfg(feature = "debug")]
     polygon_mode_line: bool,
     required_features: Features,
@@ -37,6 +38,7 @@ impl Capabilities {
             bindless: false,
             multidraw_indirect: false,
             clamp_to_border: false,
+            texture_compression: false,
             #[cfg(feature = "debug")]
             polygon_mode_line: false,
             required_features: Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES,
@@ -58,6 +60,7 @@ impl Capabilities {
                 adapter_features,
                 Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
             );
+            Self::check_feature(adapter_features, Features::TEXTURE_COMPRESSION_BC);
             Self::check_feature(adapter_features, Features::TEXTURE_BINDING_ARRAY);
             Self::check_feature(adapter_features, Features::POLYGON_MODE_LINE);
         }
@@ -85,6 +88,11 @@ impl Capabilities {
             capabilities.required_features |= Features::ADDRESS_MODE_CLAMP_TO_BORDER | Features::ADDRESS_MODE_CLAMP_TO_ZERO;
         }
 
+        if adapter_features.contains(Features::TEXTURE_COMPRESSION_BC) {
+            capabilities.texture_compression = true;
+            capabilities.required_features |= Features::TEXTURE_COMPRESSION_BC;
+        }
+
         #[cfg(feature = "debug")]
         if adapter_features.contains(Features::POLYGON_MODE_LINE) {
             capabilities.polygon_mode_line = true;
@@ -135,6 +143,11 @@ impl Capabilities {
         self.clamp_to_border
     }
 
+    /// Returns `true` if the backend supports BC texture compression.
+    pub fn supports_texture_compression(&self) -> bool {
+        self.texture_compression
+    }
+
     /// Returns `true` if the backend allows drawing triangles as lines
     /// (wireframe) instead of filled.
     #[cfg(feature = "debug")]

korangar/src/graphics/engine.rs

@@ -17,7 +17,8 @@ use winit::window::Window;
 
 use super::{
     AntiAliasingResource, Capabilities, EntityInstruction, FramePacer, FrameStage, GlobalContext, LimitFramerate, ModelInstruction, Msaa,
-    Prepare, PresentModeInfo, ScreenSpaceAntiAliasing, ShadowDetail, Ssaa, Surface, TextureSamplerType, RENDER_TO_TEXTURE_FORMAT,
+    Prepare, PresentModeInfo, ScreenSpaceAntiAliasing, ShadowDetail, Ssaa, Surface, TextureCompression, TextureSamplerType,
+    RENDER_TO_TEXTURE_FORMAT,
 };
 use crate::graphics::instruction::RenderInstruction;
 use crate::graphics::passes::*;
@@ -428,6 +429,14 @@ impl GraphicsEngine {
         ssaa
     }
 
+    pub fn check_texture_compression_requirements(&self, texture_compression: TextureCompression) -> TextureCompression {
+        if self.capabilities.supports_texture_compression() {
+            texture_compression
+        } else {
+            TextureCompression::Off
+        }
+    }
+
     pub fn on_suspended(&mut self) {
         // Android devices are expected to drop their surface view.
         if cfg!(target_os = "android") {

korangar/src/graphics/passes/directional_shadow/shader/model.wgsl

@@ -42,7 +42,7 @@ fn vs_main(
 fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
     var diffuse_color = textureSampleLevel(texture, texture_sampler, input.texture_coordinates, 0.0);
 
-    if (diffuse_color.a < 1.0) {
+    if (diffuse_color.a == 0.0) {
         discard;
     }
 

korangar/src/graphics/passes/point_shadow/shader/model.wgsl

@@ -47,7 +47,7 @@ fn fs_main(input: VertexOutput) -> @builtin(frag_depth) f32 {
 
     let light_distance = length(input.world_position.xyz - pass_uniforms.light_position.xyz);
 
-    if (diffuse_color.a != 1.0) {
+    if (diffuse_color.a == 0.0) {
         discard;
     }
 

korangar/src/graphics/settings.rs

@@ -2,9 +2,11 @@ use std::fmt::{Display, Formatter};
 #[cfg(feature = "debug")]
 use std::num::NonZeroU32;
 
+use block_compression::{BC7Settings, CompressionVariant};
 #[cfg(feature = "debug")]
 use derive_new::new;
 use serde::{Deserialize, Serialize};
+use wgpu::TextureFormat;
 
 use crate::interface::layout::ScreenSize;
 
@@ -160,6 +162,46 @@ impl Display for ScreenSpaceAntiAliasing {
     }
 }
 
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+pub enum TextureCompression {
+    Off,
+    UltraFast,
+    VeryFast,
+    Fast,
+    Normal,
+}
+
+impl TextureCompression {
+    pub fn is_uncompressed(&self) -> bool {
+        *self == TextureCompression::Off
+    }
+}
+
+impl From<TextureCompression> for TextureFormat {
+    fn from(value: TextureCompression) -> Self {
+        match value {
+            TextureCompression::Off => TextureFormat::Rgba8UnormSrgb,
+            TextureCompression::UltraFast | TextureCompression::VeryFast | TextureCompression::Fast | TextureCompression::Normal => {
+                TextureFormat::Bc7RgbaUnormSrgb
+            }
+        }
+    }
+}
+
+impl TryFrom<TextureCompression> for CompressionVariant {
+    type Error = ();
+
+    fn try_from(value: TextureCompression) -> Result<Self, Self::Error> {
+        match value {
+            TextureCompression::Off => Err(()),
+            TextureCompression::UltraFast => Ok(CompressionVariant::BC7(BC7Settings::alpha_ultrafast())),
+            TextureCompression::VeryFast => Ok(CompressionVariant::BC7(BC7Settings::alpha_very_fast())),
+            TextureCompression::Fast => Ok(CompressionVariant::BC7(BC7Settings::alpha_fast())),
+            TextureCompression::Normal => Ok(CompressionVariant::BC7(BC7Settings::alpha_basic())),
+        }
+    }
+}
+
 #[cfg(feature = "debug")]
 #[derive(Copy, Clone, Default, new)]
 pub struct RenderSettings {