DirectX 12 on Windows: the fallback when Vulkan fails, and a setting (#746)
The Windows client builds wgpu's dx12 backend. With graphicsApi:auto (the default), the renderer opens Vulkan and falls back to DirectX 12 when Vulkan has no adapter (no Vulkan driver) or its device request fails; vulkan and dx12 pick one (horizon-graphics.txt, Video Settings > Graphics API on Windows, or HORIZON_GRAPHICS_API; WGPU_BACKEND still overrides). Other systems keep their one backend. DirectX 12 keeps wgpu's indirect-draw validation: it is what passes each draw's first instance to shaders there. Occlusion culling stays Vulkan-only and flat draws Metal-only, as before; multi-draw and the GPU timer use DirectX 12's own. gpu-allocator now resolves to the windows crate wgpu-hal's dx12 code uses (0.62): with cpal's 0.54 it did not compile. A test translates every WGSL shader to HLSL as the dx12 backend does for FXC. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Generated
+11
@@ -1293,6 +1293,7 @@ dependencies = [
|
||||
"log",
|
||||
"presser",
|
||||
"thiserror 2.0.21",
|
||||
"windows 0.62.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -3027,6 +3028,12 @@ dependencies = [
|
||||
"getrandom 0.2.17",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "range-alloc"
|
||||
version = "0.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08"
|
||||
|
||||
[[package]]
|
||||
name = "raw-window-handle"
|
||||
version = "0.6.2"
|
||||
@@ -4607,6 +4614,7 @@ dependencies = [
|
||||
"android_system_properties",
|
||||
"arrayvec",
|
||||
"ash",
|
||||
"bit-set 0.10.0",
|
||||
"bitflags 2.13.2",
|
||||
"block2 0.6.2",
|
||||
"bytemuck",
|
||||
@@ -4625,11 +4633,13 @@ dependencies = [
|
||||
"objc2-foundation 0.3.2",
|
||||
"objc2-metal 0.3.2",
|
||||
"objc2-quartz-core 0.3.2",
|
||||
"once_cell",
|
||||
"ordered-float",
|
||||
"parking_lot",
|
||||
"portable-atomic",
|
||||
"portable-atomic-util",
|
||||
"profiling",
|
||||
"range-alloc",
|
||||
"raw-window-handle",
|
||||
"raw-window-metal",
|
||||
"renderdoc-sys",
|
||||
@@ -4639,6 +4649,7 @@ dependencies = [
|
||||
"wgpu-naga-bridge",
|
||||
"wgpu-types",
|
||||
"windows 0.62.2",
|
||||
"windows-core 0.62.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
||||
@@ -58,6 +58,12 @@ ureq = { version = "2", default-features = false, features = ["tls"] }
|
||||
# The server thread's CPU time per tick (`HORIZON_SPIKES`, spans.rs).
|
||||
rustix = { version = "1", default-features = false, features = ["std", "time"] }
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
# DirectX 12, where Vulkan has no adapter or device, or by choice (`graphicsApi`, graphics.rs).
|
||||
# Shaders compile with FXC (d3dcompiler_47.dll, part of Windows), or DXC when dxcompiler.dll is
|
||||
# on the PATH.
|
||||
wgpu = { version = "30.0.1", default-features = false, features = ["dx12"] }
|
||||
|
||||
[target.'cfg(windows)'.build-dependencies]
|
||||
# The icon resource in the .exe (build.rs).
|
||||
winresource = "0.1"
|
||||
@@ -74,3 +80,7 @@ rng-trace = ["horizon-core/rng-trace"]
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
|
||||
[dev-dependencies]
|
||||
# Every WGSL shader translated as wgpu's DirectX 12 backend does (gfx.rs tests).
|
||||
naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out"] }
|
||||
|
||||
@@ -8285,6 +8285,7 @@ impl Game<'_> {
|
||||
pack,
|
||||
gui,
|
||||
self.renderer.as_ref(),
|
||||
self.settings.horizon.api,
|
||||
)
|
||||
}
|
||||
fn apply_settings(&mut self) {
|
||||
@@ -11346,6 +11347,7 @@ fn build_renderer(
|
||||
pack: &PackResources,
|
||||
gui: &UiResources,
|
||||
previous: Option<&Renderer>,
|
||||
api: horizon_client::graphics::GraphicsApi,
|
||||
) -> Result<Renderer> {
|
||||
let assets = &pack.render;
|
||||
let atlas = &gui.atlas;
|
||||
@@ -11362,6 +11364,7 @@ fn build_renderer(
|
||||
(&pack.forcefield.2, pack.forcefield.0),
|
||||
&gui.panorama,
|
||||
previous,
|
||||
api,
|
||||
))?;
|
||||
renderer.hud.fire_animations = atlas
|
||||
.fire_animations
|
||||
@@ -11379,6 +11382,7 @@ fn loading_renderer(
|
||||
offscreen: bool,
|
||||
gui: Option<&UiResources>,
|
||||
previous: Option<&Renderer>,
|
||||
api: horizon_client::graphics::GraphicsApi,
|
||||
) -> Result<Renderer> {
|
||||
static FORCEFIELD: [u8; 4] = [0; 4];
|
||||
static EMPTY_HUD: [u8; 4] = [0, 0, 0, 255];
|
||||
@@ -11405,6 +11409,7 @@ fn loading_renderer(
|
||||
(&FORCEFIELD[..], 1),
|
||||
panorama,
|
||||
previous,
|
||||
api,
|
||||
))?;
|
||||
if let Some(atlas) = atlas {
|
||||
renderer.hud.fire_animations = atlas
|
||||
@@ -11670,7 +11675,13 @@ impl Loading {
|
||||
}
|
||||
};
|
||||
let offscreen = self.options.as_ref().is_some_and(|o| o.offscreen);
|
||||
match loading_renderer(window.clone(), offscreen, self.gui.as_ref(), None) {
|
||||
match loading_renderer(
|
||||
window.clone(),
|
||||
offscreen,
|
||||
self.gui.as_ref(),
|
||||
None,
|
||||
self.settings.horizon.api,
|
||||
) {
|
||||
Ok(r) => self.renderer = Some(r),
|
||||
Err(e) => {
|
||||
self.error = Some(e);
|
||||
@@ -11712,7 +11723,13 @@ impl Loading {
|
||||
if let Some(renderer) = &mut self.renderer {
|
||||
renderer.release_surface();
|
||||
}
|
||||
match loading_renderer(window, offscreen, self.gui.as_ref(), self.renderer.as_ref()) {
|
||||
match loading_renderer(
|
||||
window,
|
||||
offscreen,
|
||||
self.gui.as_ref(),
|
||||
self.renderer.as_ref(),
|
||||
self.settings.horizon.api,
|
||||
) {
|
||||
Ok(r) => {
|
||||
self.settings
|
||||
.clamp_gui_scale([r.config.width as i32, r.config.height as i32]);
|
||||
@@ -11783,6 +11800,7 @@ impl Loading {
|
||||
&loaded.pack,
|
||||
&gui,
|
||||
self.renderer.as_ref(),
|
||||
self.settings.horizon.api,
|
||||
)?;
|
||||
log::info!(
|
||||
"Horizon: world renderer ready after {} ms",
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
use crate::{
|
||||
Result,
|
||||
environment::Sky,
|
||||
graphics::GraphicsApi,
|
||||
hud::{HudBatch, HudRenderer},
|
||||
mesher::{SectionMesh, TerrainVertex, Vertex},
|
||||
sprites::SpriteAnimation,
|
||||
@@ -539,23 +540,187 @@ fn mip_chain(
|
||||
/// bounds by construction: index counts within `indices`, vertices within
|
||||
/// the section's arena range, first instances below the origins written that
|
||||
/// frame. Debug builds keep validating them; `WGPU_VALIDATION_INDIRECT_CALL=1`
|
||||
/// turns it back on.
|
||||
fn instance_descriptor() -> wgpu::InstanceDescriptor {
|
||||
/// turns it back on. DirectX 12 keeps it too: there wgpu-core's validation
|
||||
/// pass is also what passes each draw's first instance to shaders reading
|
||||
/// `instance_index`, and DirectX 12 is the fallback, where working matters
|
||||
/// more than CPU time.
|
||||
fn instance_descriptor(backends: wgpu::Backends) -> wgpu::InstanceDescriptor {
|
||||
let mut descriptor = wgpu::InstanceDescriptor::new_without_display_handle();
|
||||
if !cfg!(debug_assertions) {
|
||||
descriptor.backends = backends.with_env();
|
||||
let dx12 = cfg!(windows) && descriptor.backends.contains(wgpu::Backends::DX12);
|
||||
if !cfg!(debug_assertions) && !dx12 {
|
||||
descriptor
|
||||
.flags
|
||||
.remove(wgpu::InstanceFlags::VALIDATION_INDIRECT_CALL);
|
||||
}
|
||||
descriptor.with_env()
|
||||
}
|
||||
/// The backends to open a device on, each tried in turn until one gives a
|
||||
/// device. `api` is the player's choice (`GraphicsApi::with_env` applied);
|
||||
/// `wgpu_backend`: whether `WGPU_BACKEND` is set, which picks the backends
|
||||
/// itself. Only Windows has two: Auto tries Vulkan, then DirectX 12 when
|
||||
/// Vulkan has no adapter (no Vulkan driver) or no device. A native crash in
|
||||
/// the driver can't be caught in the game; the launcher switches the setting
|
||||
/// to DirectX 12 after one at the renderer's start (#746).
|
||||
fn backend_order(api: GraphicsApi, windows: bool, wgpu_backend: bool) -> Vec<wgpu::Backends> {
|
||||
if !windows || wgpu_backend {
|
||||
return vec![wgpu::Backends::default()];
|
||||
}
|
||||
match api {
|
||||
GraphicsApi::Auto => vec![wgpu::Backends::VULKAN, wgpu::Backends::DX12],
|
||||
GraphicsApi::Vulkan => vec![wgpu::Backends::VULKAN],
|
||||
GraphicsApi::Dx12 => vec![wgpu::Backends::DX12],
|
||||
}
|
||||
}
|
||||
fn backends_name(backends: wgpu::Backends) -> &'static str {
|
||||
match backends {
|
||||
wgpu::Backends::VULKAN => "Vulkan",
|
||||
wgpu::Backends::DX12 => "DirectX 12",
|
||||
_ => "graphics",
|
||||
}
|
||||
}
|
||||
/// A device and what it came from.
|
||||
struct Opened {
|
||||
instance: wgpu::Instance,
|
||||
surface: Option<wgpu::Surface<'static>>,
|
||||
adapter: wgpu::Adapter,
|
||||
device: wgpu::Device,
|
||||
queue: wgpu::Queue,
|
||||
}
|
||||
/// Logs the adapter and records it for telemetry and crash reports.
|
||||
fn describe_adapter(adapter: &wgpu::Adapter) {
|
||||
let info = adapter.get_info();
|
||||
log::info!(
|
||||
"Horizon renderer: {} ({:?}, {:?})",
|
||||
info.name,
|
||||
info.backend,
|
||||
info.device_type
|
||||
);
|
||||
crate::telemetry::set_gpu(
|
||||
&info.name,
|
||||
format!("{} {}", info.driver, info.driver_info)
|
||||
.trim()
|
||||
.to_owned(),
|
||||
format!("{:?}", info.backend),
|
||||
);
|
||||
crate::crash::set_detail(
|
||||
"Graphics Adapter",
|
||||
format!(
|
||||
"{} ({:?}, {:?}), driver {} {}",
|
||||
info.name, info.backend, info.device_type, info.driver, info.driver_info
|
||||
),
|
||||
);
|
||||
}
|
||||
/// Whether an adapter's texture arrays hold the block textures Horizon puts
|
||||
/// in one array.
|
||||
fn check_layers(limits: &wgpu::Limits, layers: u32) -> Result<()> {
|
||||
let needed = layers.min(sprite_split());
|
||||
if limits.max_texture_array_layers < needed {
|
||||
return Err(format!(
|
||||
"GPU supports {} texture layers; {needed} required",
|
||||
limits.max_texture_array_layers
|
||||
)
|
||||
.into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// Opens a device on the first of `backend_order`'s backends that gives one.
|
||||
/// Offscreen rendering needs no surface, so it can use a GPU the window's
|
||||
/// display cannot present from (a headless compositor).
|
||||
async fn open_device(
|
||||
window: &Arc<Window>,
|
||||
offscreen: bool,
|
||||
api: GraphicsApi,
|
||||
layers: u32,
|
||||
) -> Result<Opened> {
|
||||
let order = backend_order(
|
||||
api.with_env(),
|
||||
cfg!(windows),
|
||||
std::env::var_os("WGPU_BACKEND").is_some(),
|
||||
);
|
||||
let mut failures = Vec::new();
|
||||
for (attempt, backends) in order.iter().copied().enumerate() {
|
||||
let name = backends_name(backends);
|
||||
if attempt > 0 {
|
||||
log::warn!("Horizon renderer: trying {name} ({})", failures.join("; "));
|
||||
}
|
||||
let instance = wgpu::Instance::new(instance_descriptor(backends));
|
||||
let surface = if offscreen {
|
||||
None
|
||||
} else {
|
||||
Some(instance.create_surface(window.clone())?)
|
||||
};
|
||||
let adapter = match instance
|
||||
.request_adapter(&wgpu::RequestAdapterOptions {
|
||||
power_preference: wgpu::PowerPreference::HighPerformance,
|
||||
compatible_surface: surface.as_ref(),
|
||||
force_fallback_adapter: false,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
{
|
||||
Ok(adapter) => adapter,
|
||||
Err(e) => {
|
||||
failures.push(format!("{name}: {e}"));
|
||||
continue;
|
||||
}
|
||||
};
|
||||
describe_adapter(&adapter);
|
||||
let info = adapter.get_info();
|
||||
let limits = adapter.limits();
|
||||
if let Err(e) = check_layers(&limits, layers) {
|
||||
failures.push(format!("{name}: {e}"));
|
||||
continue;
|
||||
}
|
||||
// Mappable primary buffers: section pages that no longer fit in
|
||||
// video memory go to system memory.
|
||||
let features = timing::GpuTimer::features(&adapter)
|
||||
| cull::Cull::features(&adapter)
|
||||
| (adapter.features()
|
||||
& (wgpu::Features::INDIRECT_FIRST_INSTANCE
|
||||
| wgpu::Features::MAPPABLE_PRIMARY_BUFFERS));
|
||||
let driver = format!("{} {}", info.driver, info.driver_info);
|
||||
startup_step(format_args!(
|
||||
"requesting the device (driver {}) with features [{features}] and the adapter's \
|
||||
limits (buffers up to {} bytes, storage bindings up to {} bytes, {} texture layers)",
|
||||
match driver.trim() {
|
||||
"" => "unnamed",
|
||||
driver => driver,
|
||||
},
|
||||
limits.max_buffer_size,
|
||||
limits.max_storage_buffer_binding_size,
|
||||
limits.max_texture_array_layers,
|
||||
));
|
||||
match adapter
|
||||
.request_device(&wgpu::DeviceDescriptor {
|
||||
label: Some("Horizon device"),
|
||||
required_features: features,
|
||||
required_limits: limits,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
{
|
||||
Ok((device, queue)) => {
|
||||
return Ok(Opened {
|
||||
instance,
|
||||
surface,
|
||||
adapter,
|
||||
device,
|
||||
queue,
|
||||
});
|
||||
}
|
||||
Err(e) => failures.push(format!("{name} device: {e}")),
|
||||
}
|
||||
}
|
||||
Err(format!("{NO_GPU_DRIVER} ({})", failures.join("; ")).into())
|
||||
}
|
||||
/// What to tell a player whose system offers no usable graphics adapter.
|
||||
/// Vulkan is loaded at run time (the game links no graphics library), so a
|
||||
/// missing driver shows here rather than as a missing-DLL dialog.
|
||||
#[cfg(target_os = "windows")]
|
||||
const NO_GPU_DRIVER: &str = "No Vulkan graphics driver found: Horizon needs a GPU driver with Vulkan \
|
||||
(vulkan-1.dll comes with it). Install the latest driver for your NVIDIA, AMD or Intel GPU \
|
||||
and start the game again";
|
||||
const NO_GPU_DRIVER: &str = "No graphics driver with Vulkan or DirectX 12 found: Horizon needs a GPU \
|
||||
driver with one of them. Install the latest driver for your NVIDIA, AMD or Intel GPU and \
|
||||
start the game again";
|
||||
#[cfg(target_os = "macos")]
|
||||
const NO_GPU_DRIVER: &str = "No Metal graphics device found";
|
||||
#[cfg(not(any(target_os = "windows", target_os = "macos")))]
|
||||
@@ -610,54 +775,8 @@ impl Renderer {
|
||||
forcefield: (&[u8], u32),
|
||||
panorama_faces: &panorama::Faces,
|
||||
previous: Option<&Self>,
|
||||
api: GraphicsApi,
|
||||
) -> Result<Self> {
|
||||
// Reload resources on the same device; replacing live Vulkan devices
|
||||
// can invalidate the driver's swapchain state on the same window.
|
||||
let instance = previous.map_or_else(
|
||||
|| wgpu::Instance::new(instance_descriptor()),
|
||||
|renderer| renderer.instance.clone(),
|
||||
);
|
||||
// Offscreen rendering needs no surface, so it can use a GPU the
|
||||
// window's display cannot present from (a headless compositor).
|
||||
let surface = if offscreen {
|
||||
None
|
||||
} else {
|
||||
Some(instance.create_surface(window.clone())?)
|
||||
};
|
||||
let adapter = match previous {
|
||||
Some(renderer) => renderer.adapter.clone(),
|
||||
None => instance
|
||||
.request_adapter(&wgpu::RequestAdapterOptions {
|
||||
power_preference: wgpu::PowerPreference::HighPerformance,
|
||||
compatible_surface: surface.as_ref(),
|
||||
force_fallback_adapter: false,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.map_err(|e| format!("{NO_GPU_DRIVER} ({e})"))?,
|
||||
};
|
||||
let info = adapter.get_info();
|
||||
log::info!(
|
||||
"Horizon renderer: {} ({:?}, {:?})",
|
||||
info.name,
|
||||
info.backend,
|
||||
info.device_type
|
||||
);
|
||||
crate::telemetry::set_gpu(
|
||||
&info.name,
|
||||
format!("{} {}", info.driver, info.driver_info)
|
||||
.trim()
|
||||
.to_owned(),
|
||||
format!("{:?}", info.backend),
|
||||
);
|
||||
crate::crash::set_detail(
|
||||
"Graphics Adapter",
|
||||
format!(
|
||||
"{} ({:?}, {:?}), driver {} {}",
|
||||
info.name, info.backend, info.device_type, info.driver, info.driver_info
|
||||
),
|
||||
);
|
||||
let limits = adapter.limits();
|
||||
let split = sprite_split();
|
||||
if layers > split * SPRITE_ARRAYS {
|
||||
return Err(format!(
|
||||
@@ -666,46 +785,34 @@ impl Renderer {
|
||||
)
|
||||
.into());
|
||||
}
|
||||
if limits.max_texture_array_layers < layers.min(split) {
|
||||
return Err(format!(
|
||||
"GPU supports {} texture layers; {} required",
|
||||
limits.max_texture_array_layers,
|
||||
layers.min(split)
|
||||
)
|
||||
.into());
|
||||
}
|
||||
let (device, queue) = match previous {
|
||||
Some(renderer) => (renderer.device.clone(), renderer.queue.clone()),
|
||||
None => {
|
||||
// Mappable primary buffers: section pages that no longer fit
|
||||
// in video memory go to system memory.
|
||||
let features = timing::GpuTimer::features(&adapter)
|
||||
| cull::Cull::features(&adapter)
|
||||
| (adapter.features()
|
||||
& (wgpu::Features::INDIRECT_FIRST_INSTANCE
|
||||
| wgpu::Features::MAPPABLE_PRIMARY_BUFFERS));
|
||||
let driver = format!("{} {}", info.driver, info.driver_info);
|
||||
startup_step(format_args!(
|
||||
"requesting the device (driver {}) with features [{features}] and the adapter's \
|
||||
limits (buffers up to {} bytes, storage bindings up to {} bytes, {} texture layers)",
|
||||
match driver.trim() {
|
||||
"" => "unnamed",
|
||||
driver => driver,
|
||||
let Opened {
|
||||
instance,
|
||||
surface,
|
||||
adapter,
|
||||
device,
|
||||
queue,
|
||||
} = match previous {
|
||||
// Reload resources on the same device; replacing live Vulkan
|
||||
// devices can invalidate the driver's swapchain state on the same
|
||||
// window.
|
||||
Some(renderer) => {
|
||||
describe_adapter(&renderer.adapter);
|
||||
check_layers(&renderer.adapter.limits(), layers)?;
|
||||
Opened {
|
||||
surface: if offscreen {
|
||||
None
|
||||
} else {
|
||||
Some(renderer.instance.create_surface(window.clone())?)
|
||||
},
|
||||
limits.max_buffer_size,
|
||||
limits.max_storage_buffer_binding_size,
|
||||
limits.max_texture_array_layers,
|
||||
));
|
||||
adapter
|
||||
.request_device(&wgpu::DeviceDescriptor {
|
||||
label: Some("Horizon device"),
|
||||
required_features: features,
|
||||
required_limits: limits.clone(),
|
||||
..Default::default()
|
||||
})
|
||||
.await?
|
||||
instance: renderer.instance.clone(),
|
||||
adapter: renderer.adapter.clone(),
|
||||
device: renderer.device.clone(),
|
||||
queue: renderer.queue.clone(),
|
||||
}
|
||||
}
|
||||
None => open_device(&window, offscreen, api, layers).await?,
|
||||
};
|
||||
let info = adapter.get_info();
|
||||
let size = window.inner_size();
|
||||
let (config, present_modes) = if let Some(surface) = &surface {
|
||||
let mut config = surface
|
||||
@@ -3747,6 +3854,84 @@ mod tests {
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn windows_tries_vulkan_then_directx_12() {
|
||||
use super::{GraphicsApi, backend_order};
|
||||
use wgpu::Backends;
|
||||
assert_eq!(
|
||||
backend_order(GraphicsApi::Auto, true, false),
|
||||
[Backends::VULKAN, Backends::DX12]
|
||||
);
|
||||
assert_eq!(
|
||||
backend_order(GraphicsApi::Vulkan, true, false),
|
||||
[Backends::VULKAN]
|
||||
);
|
||||
assert_eq!(
|
||||
backend_order(GraphicsApi::Dx12, true, false),
|
||||
[Backends::DX12]
|
||||
);
|
||||
// WGPU_BACKEND picks the backends itself; other systems have one.
|
||||
for api in GraphicsApi::ALL {
|
||||
assert_eq!(backend_order(api, true, true), [Backends::default()]);
|
||||
assert_eq!(backend_order(api, false, false), [Backends::default()]);
|
||||
}
|
||||
}
|
||||
/// Every WGSL shader file translates to HLSL as wgpu's DirectX 12 backend
|
||||
/// writes it for FXC (shader model 5.1), entry point by entry point.
|
||||
#[test]
|
||||
fn shaders_translate_to_hlsl_for_directx_12() {
|
||||
fn wgsl_files(dir: &std::path::Path, out: &mut Vec<std::path::PathBuf>) {
|
||||
for entry in std::fs::read_dir(dir).unwrap() {
|
||||
let path = entry.unwrap().path();
|
||||
if path.is_dir() {
|
||||
wgsl_files(&path, out);
|
||||
} else if path.extension().is_some_and(|e| e == "wgsl") {
|
||||
out.push(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut files = Vec::new();
|
||||
wgsl_files(
|
||||
std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/src")),
|
||||
&mut files,
|
||||
);
|
||||
assert!(files.len() >= 10, "{files:?}");
|
||||
for path in files {
|
||||
let text = std::fs::read_to_string(&path).unwrap();
|
||||
// entity.wgsl comes after the overlay's constants (entity_shader).
|
||||
let module = naga::front::wgsl::parse_str(&text)
|
||||
.or_else(|_| {
|
||||
naga::front::wgsl::parse_str(&(crate::overlay::wgsl_constants() + &text))
|
||||
})
|
||||
.unwrap_or_else(|e| panic!("{}: {e}", path.display()));
|
||||
let info = naga::valid::Validator::new(
|
||||
naga::valid::ValidationFlags::all(),
|
||||
naga::valid::Capabilities::all(),
|
||||
)
|
||||
.validate(&module)
|
||||
.unwrap_or_else(|e| panic!("{}: {e:?}", path.display()));
|
||||
for entry in &module.entry_points {
|
||||
let (module, info) = naga::back::pipeline_constants::process_overrides(
|
||||
&module,
|
||||
&info,
|
||||
Some((entry.stage, &entry.name)),
|
||||
&Default::default(),
|
||||
)
|
||||
.unwrap();
|
||||
let mut hlsl = String::new();
|
||||
naga::back::hlsl::Writer::new(
|
||||
&mut hlsl,
|
||||
&naga::back::hlsl::Options::default(),
|
||||
&naga::back::hlsl::PipelineOptions {
|
||||
entry_point: Some((entry.stage, entry.name.clone())),
|
||||
},
|
||||
)
|
||||
.write(&module, &info, None)
|
||||
.unwrap_or_else(|e| panic!("{} {}: {e}", path.display(), entry.name));
|
||||
assert!(!hlsl.is_empty());
|
||||
}
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn entity_shader_validates_with_its_overlay_constants() {
|
||||
let module = naga::front::wgsl::parse_str(&super::entity_shader()).unwrap();
|
||||
naga::valid::Validator::new(
|
||||
@@ -3806,12 +3991,20 @@ mod tests {
|
||||
assert_eq!(super::outline_width(3840), 5.0);
|
||||
}
|
||||
#[test]
|
||||
fn indirect_draws_are_validated_only_in_debug_builds() {
|
||||
if std::env::var_os("WGPU_VALIDATION_INDIRECT_CALL").is_none() {
|
||||
let flags = super::instance_descriptor().flags;
|
||||
fn indirect_draws_are_validated_only_in_debug_builds_and_on_directx_12() {
|
||||
let validated = |backends| {
|
||||
super::instance_descriptor(backends)
|
||||
.flags
|
||||
.contains(wgpu::InstanceFlags::VALIDATION_INDIRECT_CALL)
|
||||
};
|
||||
if std::env::var_os("WGPU_VALIDATION_INDIRECT_CALL").is_none()
|
||||
&& std::env::var_os("WGPU_BACKEND").is_none()
|
||||
{
|
||||
assert_eq!(validated(wgpu::Backends::default()), cfg!(debug_assertions));
|
||||
assert_eq!(validated(wgpu::Backends::VULKAN), cfg!(debug_assertions));
|
||||
assert_eq!(
|
||||
flags.contains(wgpu::InstanceFlags::VALIDATION_INDIRECT_CALL),
|
||||
cfg!(debug_assertions)
|
||||
validated(wgpu::Backends::DX12),
|
||||
cfg!(debug_assertions) || cfg!(windows)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -93,6 +93,48 @@ impl PresentMode {
|
||||
}
|
||||
}
|
||||
|
||||
/// The graphics API the renderer runs on. Only Windows has a choice: the
|
||||
/// other systems always use their one backend (Vulkan on Linux, Metal on
|
||||
/// macOS). Applies at the next start.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
|
||||
pub enum GraphicsApi {
|
||||
/// Vulkan, and DirectX 12 when Vulkan has no adapter or device.
|
||||
#[default]
|
||||
Auto,
|
||||
Vulkan,
|
||||
Dx12,
|
||||
}
|
||||
impl GraphicsApi {
|
||||
pub const ALL: [GraphicsApi; 3] = [GraphicsApi::Auto, GraphicsApi::Vulkan, GraphicsApi::Dx12];
|
||||
pub fn name(self) -> &'static str {
|
||||
match self {
|
||||
GraphicsApi::Auto => "auto",
|
||||
GraphicsApi::Vulkan => "vulkan",
|
||||
GraphicsApi::Dx12 => "dx12",
|
||||
}
|
||||
}
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
GraphicsApi::Auto => "Auto",
|
||||
GraphicsApi::Vulkan => "Vulkan",
|
||||
GraphicsApi::Dx12 => "DirectX 12",
|
||||
}
|
||||
}
|
||||
/// The API a name stands for, ignoring case; `None` for anything else.
|
||||
pub fn from_name(s: &str) -> Option<Self> {
|
||||
Self::ALL
|
||||
.into_iter()
|
||||
.find(|api| api.name().eq_ignore_ascii_case(s.trim()))
|
||||
}
|
||||
/// `HORIZON_GRAPHICS_API` (auto, vulkan or dx12) if set, else the setting.
|
||||
pub fn with_env(self) -> Self {
|
||||
std::env::var("HORIZON_GRAPHICS_API")
|
||||
.ok()
|
||||
.and_then(|v| Self::from_name(&v))
|
||||
.unwrap_or(self)
|
||||
}
|
||||
}
|
||||
|
||||
/// What the frame limiter does in the last half millisecond before a frame.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
|
||||
pub enum Pacing {
|
||||
@@ -149,6 +191,8 @@ pub struct Graphics {
|
||||
/// The Horizon shader pack in `shaderpacks/` (its folder name); empty:
|
||||
/// none, the vanilla picture (docs/shader-packs.md).
|
||||
pub shader_pack: String,
|
||||
/// The graphics API (Windows only; see `GraphicsApi`).
|
||||
pub api: GraphicsApi,
|
||||
}
|
||||
impl Default for Graphics {
|
||||
fn default() -> Self {
|
||||
@@ -172,6 +216,7 @@ impl Default for Graphics {
|
||||
advanced: false,
|
||||
battery: false,
|
||||
shader_pack: String::new(),
|
||||
api: GraphicsApi::Auto,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -222,6 +267,7 @@ impl Graphics {
|
||||
"level" => g.advanced = value == "advanced",
|
||||
"batteryMode" => g.battery = flag(g.battery),
|
||||
"shaderPack" => g.shader_pack = value.to_string(),
|
||||
"graphicsApi" => g.api = GraphicsApi::from_name(value).unwrap_or_default(),
|
||||
"overlay" => {
|
||||
g.overlay = match value {
|
||||
"fps" => Overlay::Fps,
|
||||
@@ -236,7 +282,7 @@ impl Graphics {
|
||||
}
|
||||
pub fn serialize(&self) -> String {
|
||||
format!(
|
||||
"preset:{}\ncaveCulling:{}\ncullLeaves:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nlevel:{}\nbatteryMode:{}\nshaderPack:{}\n",
|
||||
"preset:{}\ncaveCulling:{}\ncullLeaves:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nlevel:{}\nbatteryMode:{}\nshaderPack:{}\ngraphicsApi:{}\n",
|
||||
self.preset.name(),
|
||||
bool_text(self.cave_culling),
|
||||
bool_text(self.cull_leaves),
|
||||
@@ -263,6 +309,7 @@ impl Graphics {
|
||||
if self.advanced { "advanced" } else { "simple" },
|
||||
bool_text(self.battery),
|
||||
self.shader_pack,
|
||||
self.api.name(),
|
||||
)
|
||||
}
|
||||
pub fn save(&self, dir: &Path) {
|
||||
@@ -355,6 +402,7 @@ mod tests {
|
||||
advanced: true,
|
||||
battery: true,
|
||||
shader_pack: "horizon-sample".into(),
|
||||
api: GraphicsApi::Dx12,
|
||||
};
|
||||
assert_eq!(Graphics::parse(&g.serialize()), g);
|
||||
assert_eq!(Graphics::parse(""), Graphics::default());
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//! they show, in what groups, with what description and cost, and their
|
||||
//! input. How they look comes from `graphics_style`.
|
||||
use crate::{
|
||||
graphics::{Overlay, Pacing, PresentMode, Preset},
|
||||
graphics::{GraphicsApi, Overlay, Pacing, PresentMode, Preset},
|
||||
graphics_style::{Cost, STYLE},
|
||||
hud::{HudAtlas, HudBatch},
|
||||
options_ui::Opt,
|
||||
@@ -38,6 +38,7 @@ pub enum H {
|
||||
Antialiasing,
|
||||
BatteryMode,
|
||||
ShaderPack,
|
||||
GraphicsApi,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
@@ -99,7 +100,7 @@ pub fn rows(level: Level) -> Vec<Row> {
|
||||
None,
|
||||
"Sets the options below together. Changing one makes it Custom.",
|
||||
);
|
||||
match level {
|
||||
let mut rows = match level {
|
||||
Level::Simple => vec![preset, render, fov, fps, vsync, gui],
|
||||
Level::Advanced => vec![
|
||||
Row::Header("Rendering"),
|
||||
@@ -248,6 +249,11 @@ pub fn rows(level: Level) -> Vec<Row> {
|
||||
None,
|
||||
"Threads that generate, light and mesh chunks. Next start.",
|
||||
),
|
||||
h(
|
||||
H::GraphicsApi,
|
||||
None,
|
||||
"Vulkan, or DirectX 12 where Vulkan fails. Next start.",
|
||||
),
|
||||
h(
|
||||
H::UploadBudget,
|
||||
Low,
|
||||
@@ -260,7 +266,14 @@ pub fn rows(level: Level) -> Vec<Row> {
|
||||
"Frame rate and frame times over the game, with a graph.",
|
||||
),
|
||||
],
|
||||
};
|
||||
// Only Windows has more than one graphics API.
|
||||
if !cfg!(windows) {
|
||||
rows.retain(
|
||||
|row| !matches!(row, Row::Setting(s) if s.item == Item::Horizon(H::GraphicsApi)),
|
||||
);
|
||||
}
|
||||
rows
|
||||
}
|
||||
|
||||
const UPLOAD_STEPS: [u32; 8] = [0, 256, 512, 1024, 2048, 4096, 8192, 16384];
|
||||
@@ -342,6 +355,7 @@ impl H {
|
||||
H::ResolutionScale => labelled("Resolution Scale", format!("{}%", g.resolution_scale)),
|
||||
H::Antialiasing => labelled("Anti-aliasing", if g.fxaa { "FXAA" } else { "Off" }),
|
||||
H::BatteryMode => labelled("Battery Mode", on_off(g.battery)),
|
||||
H::GraphicsApi => labelled("Graphics API", g.api.label()),
|
||||
H::ShaderPack => match g.shader_pack.as_str() {
|
||||
"" => labelled("Shader Pack", "Off"),
|
||||
id => labelled("Shader Pack", id),
|
||||
@@ -393,6 +407,7 @@ impl H {
|
||||
H::PresentMode => g.present_mode = step(&PresentMode::ALL, g.present_mode, back),
|
||||
H::Antialiasing => g.fxaa = !g.fxaa,
|
||||
H::BatteryMode => g.battery = !g.battery,
|
||||
H::GraphicsApi => g.api = step(&GraphicsApi::ALL, g.api, back),
|
||||
H::ShaderPack => {
|
||||
// Off, then every pack in shaderpacks/ by folder name.
|
||||
let dir = std::env::current_dir()
|
||||
@@ -497,6 +512,7 @@ impl Item {
|
||||
| H::Workers
|
||||
| H::BatteryMode
|
||||
| H::ShaderPack
|
||||
| H::GraphicsApi
|
||||
) | Item::Vanilla(
|
||||
Opt::GuiScale
|
||||
| Opt::Fullscreen
|
||||
|
||||
Reference in New Issue
Block a user