bite-gp-windows 1.24.401

use std::{
    slice,
    sync::{Arc, OnceLock},
};

use anyhow::{Context, Result};
use collections::HashMap;
use gpui_util::ResultExt;
use windows::{
    Win32::{
        Foundation::{HANDLE, HWND},
        Graphics::{
            Direct3D::*,
            Direct3D11::*,
            DirectComposition::*,
            DirectWrite::*,
            Dxgi::{Common::*, *},
        },
    },
    core::{HSTRING, Interface},
};

use crate::directx_renderer::shader_resources::{RawShaderBytes, ShaderModule, ShaderTarget};
use crate::*;
use gpui_engine::{
    AtlasTextureId, CustomRenderPrimitive, DirectXSource, GpuRenderer, MonochromeSprite,
    PaintSurface, Path, PlatformAtlas, PolychromeSprite, PrimitiveBatch, Quad, Scene,
    SceneRenderer, SharedDirectXSurface, SubpixelSprite, SurfaceSource, Underline,
    get_gamma_correction_ratios,
};
use gpui_platform::*;

pub(crate) const DISABLE_DIRECT_COMPOSITION: &str = "GPUI_DISABLE_DIRECT_COMPOSITION";
const RENDER_TARGET_FORMAT: DXGI_FORMAT = DXGI_FORMAT_B8G8R8A8_UNORM;
// This configuration is used for MSAA rendering on paths only, and it's guaranteed to be supported by DirectX 11.
const PATH_MULTISAMPLE_COUNT: u32 = 4;
const MAX_INSTANCE_BUFFER_SIZE: usize = 256 * 1024 * 1024;
/// The 2D texture limit of every Direct3D 11 feature level GPUI runs on; the atlas clamps to the
/// same value (`MAX_ATLAS_SIZE`).
const MAX_TEXTURE_SIZE: u32 = 16_384;
/// How many frames a view the renderer made for a producer's texture outlives the last frame that
/// named it before the cache drops it. See `DirectXRenderer::surface_view` for the rule this is a
/// part of.
const SURFACE_VIEW_CACHE_PATIENCE: u64 = 2;

pub(crate) struct FontInfo {
    pub gamma_ratios: [f32; 4],
    pub grayscale_enhanced_contrast: f32,
    pub subpixel_enhanced_contrast: f32,
    pub is_bgr: bool,
}

/// One entry of [`DirectXRenderer`]'s surface-view cache: a view the renderer made for a producer's
/// `Texture`-variant surface, and the frame that last named it.
struct SurfaceView {
    view: ID3D11ShaderResourceView,
    last_used: u64,
}

/// One entry of [`DirectXRenderer`]'s shared-surface cache: a producer's texture, opened on the
/// renderer's device, and the view of it.
struct SharedSurfaceView {
    view: ID3D11ShaderResourceView,
    /// Held so the view's resource cannot be released underneath it.
    _texture: ID3D11Texture2D,
    last_used: u64,
}

/// One entry of [`DirectXRenderer`]'s shared-fence cache: a producer's fence, opened on the
/// renderer's device.
struct SharedFenceEntry {
    fence: ID3D11Fence,
    last_used: u64,
}

pub struct DirectXRenderer {
    hwnd: HWND,
    atlas: Arc<DirectXAtlas>,
    devices: Option<DirectXRendererDevices>,
    resources: Option<DirectXResources>,
    globals: DirectXGlobalElements,
    pipelines: DirectXRenderPipelines,
    direct_composition: Option<DirectComposition>,
    font_info: &'static FontInfo,
    background_appearance: WindowBackgroundAppearance,

    width: u32,
    height: u32,

    /// Whether we want to skip drwaing due to device lost events.
    ///
    /// In that case we want to discard the first frame that we draw as we got reset in the middle of a frame
    /// meaning we lost all the allocated gpu textures and scene resources.
    skip_draws: bool,

    /// Views the renderer made for the `Texture` variant of a surface, keyed by the texture's raw COM
    /// interface pointer. See [`DirectXRenderer::surface_view`] for why this exists and for the
    /// rule that invalidates and prunes it.
    surface_views: HashMap<usize, SurfaceView>,
    /// Producer-shared textures the renderer opened on its own device, keyed by their NT handle. See
    /// [`DirectXRenderer::surface_view`] for the rule that invalidates and prunes it.
    shared_surfaces: HashMap<usize, SharedSurfaceView>,
    /// Producer-shared fences the renderer opened on its own device, keyed by their NT handle.
    shared_fences: HashMap<usize, SharedFenceEntry>,
    /// The frame the surface-view cache stamps entries with; incremented once per `render`.
    frame_index: u64,
}

/// Direct3D objects
#[derive(Clone)]
pub(crate) struct DirectXRendererDevices {
    pub(crate) adapter: IDXGIAdapter1,
    pub(crate) dxgi_factory: IDXGIFactory6,
    pub(crate) device: ID3D11Device,
    pub(crate) device_context: ID3D11DeviceContext,
    dxgi_device: Option<IDXGIDevice>,
    annotation: Option<ID3DUserDefinedAnnotation>,
}

struct DirectXResources {
    // Direct3D rendering objects
    swap_chain: IDXGISwapChain1,
    render_target: Option<ID3D11Texture2D>,
    render_target_view: Option<ID3D11RenderTargetView>,

    // Path intermediate textures (with MSAA)
    path_intermediate_texture: ID3D11Texture2D,
    path_intermediate_srv: Option<ID3D11ShaderResourceView>,
    path_intermediate_msaa_texture: ID3D11Texture2D,
    path_intermediate_msaa_view: Option<ID3D11RenderTargetView>,

    // Cached viewport
    viewport: D3D11_VIEWPORT,
}

struct DirectXRenderPipelines {
    shadow_pipeline: PipelineState<Shadow>,
    quad_pipeline: PipelineState<Quad>,
    path_rasterization_pipeline: PipelineState<PathRasterizationSprite>,
    path_sprite_pipeline: PipelineState<PathSprite>,
    underline_pipeline: PipelineState<Underline>,
    mono_sprites: PipelineState<MonochromeSprite>,
    subpixel_sprites: PipelineState<SubpixelSprite>,
    poly_sprites: PipelineState<PolychromeSprite>,
    /// The quads' instance record and vertex entry point with the imported-texture fragment, so a
    /// producer's texture lands with a quad's geometry, clip and corner coverage.
    imported_texture_pipeline: PipelineState<Quad>,
    /// The same record and fragment as `imported_texture_pipeline`, with a buffer of its own: the
    /// surfaces are a batch separate from the custom primitives, and each pipeline indexes its own
    /// instance buffer from zero.
    surfaces_pipeline: PipelineState<Quad>,
}

struct DirectXGlobalElements {
    global_params_buffer: Option<ID3D11Buffer>,
    batch_params_buffer: Option<ID3D11Buffer>,
    sampler: Option<ID3D11SamplerState>,
    /// The imported-texture path's sampler. Clamped where the atlas's wraps, so a clip against a
    /// rounded corner cannot bleed the opposite edge of a producer's texture into the blend.
    imported_texture_sampler: Option<ID3D11SamplerState>,
}

struct Annotation<'a>(&'a ID3DUserDefinedAnnotation);

impl<'a> Annotation<'a> {
    fn new(annotation: &'a ID3DUserDefinedAnnotation, label: HSTRING) -> Self {
        unsafe { annotation.BeginEvent(&label) };
        Self(annotation)
    }
}

impl Drop for Annotation<'_> {
    fn drop(&mut self) {
        unsafe { self.0.EndEvent() };
    }
}

struct DirectComposition {
    comp_device: IDCompositionDevice,
    comp_target: IDCompositionTarget,
    comp_visual: IDCompositionVisual,
}

impl DirectXRendererDevices {
    pub(crate) fn new(
        directx_devices: &DirectXDevices,
        disable_direct_composition: bool,
    ) -> Result<Self> {
        let DirectXDevices {
            adapter,
            dxgi_factory,
            device,
            device_context,
            ..
        } = directx_devices;
        let dxgi_device = if disable_direct_composition {
            None
        } else {
            Some(device.cast().context("Creating DXGI device")?)
        };
        let annotation = device_context.cast().ok();

        Ok(Self {
            adapter: adapter.clone(),
            dxgi_factory: dxgi_factory.clone(),
            device: device.clone(),
            device_context: device_context.clone(),
            dxgi_device,
            annotation,
        })
    }
}

impl DirectXRenderer {
    pub(crate) fn new(
        hwnd: HWND,
        directx_devices: &DirectXDevices,
        disable_direct_composition: bool,
    ) -> Result<Self> {
        if disable_direct_composition {
            log::info!("Direct Composition is disabled.");
        }

        let devices = DirectXRendererDevices::new(directx_devices, disable_direct_composition)
            .context("Creating DirectX devices")?;
        let atlas = Arc::new(DirectXAtlas::new(&devices.device, &devices.device_context));

        let resources = DirectXResources::new(&devices, 1, 1, hwnd, disable_direct_composition)
            .context("Creating DirectX resources")?;
        let globals = DirectXGlobalElements::new(&devices.device)
            .context("Creating DirectX global elements")?;
        let pipelines = DirectXRenderPipelines::new(&devices.device)
            .context("Creating DirectX render pipelines")?;

        let direct_composition = if disable_direct_composition {
            None
        } else {
            let composition = DirectComposition::new(devices.dxgi_device.as_ref().unwrap(), hwnd)
                .context("Creating DirectComposition")?;
            composition
                .set_swap_chain(&resources.swap_chain)
                .context("Setting swap chain for DirectComposition")?;
            Some(composition)
        };

        Ok(DirectXRenderer {
            hwnd,
            atlas,
            devices: Some(devices),
            resources: Some(resources),
            globals,
            pipelines,
            direct_composition,
            font_info: Self::get_font_info(),
            background_appearance: WindowBackgroundAppearance::Opaque,
            width: 1,
            height: 1,
            skip_draws: false,
            surface_views: HashMap::default(),
            shared_surfaces: HashMap::default(),
            shared_fences: HashMap::default(),
            frame_index: 0,
        })
    }

    pub(crate) fn set_background_appearance(
        &mut self,
        background_appearance: WindowBackgroundAppearance,
    ) {
        self.background_appearance = background_appearance;
    }

    pub(crate) fn sprite_atlas(&self) -> Arc<dyn PlatformAtlas> {
        self.atlas.clone()
    }

    fn pre_draw(&self, clear_color: &[f32; 4]) -> Result<()> {
        let resources = self.resources.as_ref().expect("resources missing");
        let device_context = &self
            .devices
            .as_ref()
            .expect("devices missing")
            .device_context;
        update_buffer(
            device_context,
            self.globals.global_params_buffer.as_ref().unwrap(),
            &[GlobalParams {
                gamma_ratios: self.font_info.gamma_ratios,
                viewport_size: [resources.viewport.Width, resources.viewport.Height],
                grayscale_enhanced_contrast: self.font_info.grayscale_enhanced_contrast,
                subpixel_enhanced_contrast: self.font_info.subpixel_enhanced_contrast,
                is_bgr: self.font_info.is_bgr as u32,
                _pad: [0; 3],
            }],
        )?;
        unsafe {
            device_context.ClearRenderTargetView(
                resources
                    .render_target_view
                    .as_ref()
                    .context("missing render target view")?,
                clear_color,
            );
            device_context
                .OMSetRenderTargets(Some(slice::from_ref(&resources.render_target_view)), None);
            device_context.RSSetViewports(Some(slice::from_ref(&resources.viewport)));
            device_context
                .VSSetConstantBuffers(0, Some(slice::from_ref(&self.globals.global_params_buffer)));
            device_context
                .VSSetConstantBuffers(1, Some(slice::from_ref(&self.globals.batch_params_buffer)));
            device_context
                .PSSetConstantBuffers(0, Some(slice::from_ref(&self.globals.global_params_buffer)));
        }
        Ok(())
    }

    #[inline]
    fn present(&mut self) -> Result<()> {
        let result = unsafe {
            self.resources
                .as_ref()
                .expect("resources missing")
                .swap_chain
                .Present(0, DXGI_PRESENT(0))
        };
        result.ok().context("Presenting swap chain failed")
    }

    pub(crate) fn handle_device_lost(&mut self, directx_devices: &DirectXDevices) -> Result<()> {
        try_to_recover_from_device_lost(|| {
            self.handle_device_lost_impl(directx_devices)
                .context("DirectXRenderer handling device lost")
        })
    }

    fn handle_device_lost_impl(&mut self, directx_devices: &DirectXDevices) -> Result<()> {
        let disable_direct_composition = self.direct_composition.is_none();

        // The cached views were made on the device being replaced, so the new one cannot sample
        // them; drop them before the old device is released below.
        self.surface_views.clear();
        self.shared_surfaces.clear();
        self.shared_fences.clear();

        unsafe {
            #[cfg(debug_assertions)]
            if let Some(devices) = &self.devices {
                report_live_objects(&devices.device)
                    .context("Failed to report live objects after device lost")
                    .log_err();
            }

            self.resources.take();
            if let Some(devices) = &self.devices {
                devices.device_context.OMSetRenderTargets(None, None);
                devices.device_context.ClearState();
                devices.device_context.Flush();
                #[cfg(debug_assertions)]
                report_live_objects(&devices.device)
                    .context("Failed to report live objects after device lost")
                    .log_err();
            }

            self.direct_composition.take();
            self.devices.take();
        }

        let devices = DirectXRendererDevices::new(directx_devices, disable_direct_composition)
            .context("Recreating DirectX devices")?;
        let resources = DirectXResources::new(
            &devices,
            self.width,
            self.height,
            self.hwnd,
            disable_direct_composition,
        )
        .context("Creating DirectX resources")?;
        let globals = DirectXGlobalElements::new(&devices.device)
            .context("Creating DirectXGlobalElements")?;
        let pipelines = DirectXRenderPipelines::new(&devices.device)
            .context("Creating DirectXRenderPipelines")?;

        let direct_composition = if disable_direct_composition {
            None
        } else {
            let composition =
                DirectComposition::new(devices.dxgi_device.as_ref().unwrap(), self.hwnd)?;
            composition.set_swap_chain(&resources.swap_chain)?;
            Some(composition)
        };

        self.atlas
            .handle_device_lost(&devices.device, &devices.device_context);

        unsafe {
            devices
                .device_context
                .OMSetRenderTargets(Some(slice::from_ref(&resources.render_target_view)), None);
        }
        self.devices = Some(devices);
        self.resources = Some(resources);
        self.globals = globals;
        self.pipelines = pipelines;
        self.direct_composition = direct_composition;
        self.skip_draws = true;
        Ok(())
    }

    pub(crate) fn draw(
        &mut self,
        scene: &Scene,
        background_appearance: WindowBackgroundAppearance,
    ) -> Result<()> {
        if self.skip_draws {
            // skip drawing this frame, we just recovered from a device lost event
            // and so likely do not have the textures anymore that are required for drawing
            return Ok(());
        }
        self.render(scene, background_appearance)?;
        self.present()
    }

    /// Clear the render target for `background_appearance` and encode every
    /// primitive batch of `scene` into it, without presenting. Shared by
    /// [`draw`](Self::draw) (which then presents) and `render_scene` (which renders into the same
    /// target and does not), so the two cannot drift.
    fn render(
        &mut self,
        scene: &Scene,
        background_appearance: WindowBackgroundAppearance,
    ) -> Result<()> {
        // Age the surface-view cache one frame; see `surface_view` for what an entry's stamp means.
        self.frame_index = self.frame_index.wrapping_add(1);
        self.pre_draw(&match background_appearance {
            WindowBackgroundAppearance::Opaque => [1.0f32; 4],
            _ => [0.0f32; 4],
        })?;
        self.upload_scene_buffers(scene)?;

        let annotation = self
            .devices
            .as_ref()
            .and_then(|devices| devices.annotation.clone())
            .filter(|annotation| unsafe { annotation.GetStatus().as_bool() });
        for batch in scene.batches() {
            let _annotation = annotation
                .as_ref()
                .map(|annotation| Annotation::new(annotation, HSTRING::from(batch.label())));
            match batch {
                PrimitiveBatch::Shadows(range) => self.draw_shadows(range.start, range.len()),
                PrimitiveBatch::Quads(range) => self.draw_quads(range.start, range.len()),
                PrimitiveBatch::Paths(range) => {
                    let paths = &scene.paths[range];
                    self.draw_paths_to_intermediate(paths)?;
                    self.draw_paths_from_intermediate(paths)
                }
                PrimitiveBatch::Underlines(range) => self.draw_underlines(range.start, range.len()),
                PrimitiveBatch::MonochromeSprites { texture_id, range } => {
                    self.draw_monochrome_sprites(texture_id, range.start, range.len())
                }
                PrimitiveBatch::SubpixelSprites { texture_id, range } => {
                    self.draw_subpixel_sprites(texture_id, range.start, range.len())
                }
                PrimitiveBatch::PolychromeSprites { texture_id, range } => {
                    self.draw_polychrome_sprites(texture_id, range.start, range.len())
                }
                PrimitiveBatch::Surfaces(range) => {
                    self.draw_surfaces(range.start, &scene.surfaces[range])
                }
                PrimitiveBatch::Custom(range) => {
                    self.draw_custom(range.start, &scene.custom[range])
                }
            }
            .with_context(|| {
                format!(
                    "scene too large:\
                    {} paths, {} shadows, {} quads, {} underlines, {} mono, {} subpixel, {} poly, {} surfaces",
                    scene.paths.len(),
                    scene.shadows.len(),
                    scene.quads.len(),
                    scene.underlines.len(),
                    scene.monochrome_sprites.len(),
                    scene.subpixel_sprites.len(),
                    scene.polychrome_sprites.len(),
                    scene.surfaces.len(),
                )
            })?;
        }
        self.prune_surface_views();
        Ok(())
    }

    /// Render `scene` into the target **without presenting**, then read it back as a CPU image.
    ///
    /// The offscreen contract, in the shape the other two renderers have it: render, and read the
    /// target back on demand. Direct3D's target is its window's swap chain — the renderer is built
    /// around one — so "offscreen" here is "rendered and not presented", which is what a headless
    /// capture needs and what the window need never be shown for.
    fn read_render_target(&mut self) -> Result<gpui_engine::PixelBuffer> {
        let devices = self.devices.as_ref().context("devices missing")?;
        let device = &devices.device;
        let context = &devices.device_context;
        let resources = self.resources.as_ref().context("resources missing")?;
        let render_target = resources
            .render_target
            .as_ref()
            .context("render target missing")?;

        // A CPU-readable copy of the render target.
        let mut desc = D3D11_TEXTURE2D_DESC::default();
        unsafe { render_target.GetDesc(&mut desc) };
        let width = desc.Width;
        let height = desc.Height;
        let staging_desc = D3D11_TEXTURE2D_DESC {
            Usage: D3D11_USAGE_STAGING,
            BindFlags: 0,
            CPUAccessFlags: D3D11_CPU_ACCESS_READ.0 as u32,
            MiscFlags: 0,
            MipLevels: 1,
            ArraySize: 1,
            SampleDesc: DXGI_SAMPLE_DESC {
                Count: 1,
                Quality: 0,
            },
            ..desc
        };
        let mut staging: Option<ID3D11Texture2D> = None;
        unsafe { device.CreateTexture2D(&staging_desc, None, Some(&mut staging))? };
        let staging = staging.context("creating staging texture")?;
        unsafe { context.CopyResource(&staging, render_target) };

        let mut mapped = D3D11_MAPPED_SUBRESOURCE::default();
        unsafe { context.Map(&staging, 0, D3D11_MAP_READ, 0, Some(&mut mapped))? };
        let row_bytes = (width as usize) * 4;
        let mut pixels = vec![0u8; row_bytes * height as usize];
        // SAFETY: `Map` succeeded, so `pData` points at `RowPitch * height`
        // readable bytes for as long as the mapping is held, and `RowPitch >=
        // row_bytes` (it only ever adds trailing padding). `pixels` is sized
        // `row_bytes * height`, so every copy stays in bounds on both sides,
        // and the regions cannot overlap (`pixels` is a fresh allocation).
        unsafe {
            let src = mapped.pData as *const u8;
            for row in 0..height as usize {
                let s = src.add(row * mapped.RowPitch as usize);
                let d = pixels.as_mut_ptr().add(row * row_bytes);
                std::ptr::copy_nonoverlapping(s, d, row_bytes);
            }
            context.Unmap(&staging, 0);
        }
        // The render target is BGRA; `PixelBuffer` is RGBA8.
        for px in pixels.chunks_exact_mut(4) {
            px.swap(0, 2);
        }
        gpui_engine::PixelBuffer::new(width, height, pixels)
    }

    pub(crate) fn resize(&mut self, new_size: Size<DevicePixels>) -> Result<()> {
        let width = new_size.width.0.max(1) as u32;
        let height = new_size.height.0.max(1) as u32;
        if self.width == width && self.height == height {
            return Ok(());
        }
        self.width = width;
        self.height = height;

        // Clear the render target before resizing
        let devices = self.devices.as_ref().context("devices missing")?;
        unsafe { devices.device_context.OMSetRenderTargets(None, None) };
        let resources = self.resources.as_mut().context("resources missing")?;
        resources.render_target.take();
        resources.render_target_view.take();

        // Resizing the swap chain requires a call to the underlying DXGI adapter, which can return the device removed error.
        // The app might have moved to a monitor that's attached to a different graphics device.
        // When a graphics device is removed or reset, the desktop resolution often changes, resulting in a window size change.
        // But here we just return the error, because we are handling device lost scenarios elsewhere.
        unsafe {
            resources
                .swap_chain
                .ResizeBuffers(
                    BUFFER_COUNT as u32,
                    width,
                    height,
                    RENDER_TARGET_FORMAT,
                    DXGI_SWAP_CHAIN_FLAG(0),
                )
                .context("Failed to resize swap chain")?;
        }

        resources.recreate_resources(devices, width, height)?;

        unsafe {
            devices
                .device_context
                .OMSetRenderTargets(Some(slice::from_ref(&resources.render_target_view)), None);
        }

        Ok(())
    }

    fn upload_scene_buffers(&mut self, scene: &Scene) -> Result<()> {
        let devices = self.devices.as_ref().context("devices missing")?;

        if !scene.shadows.is_empty() {
            self.pipelines.shadow_pipeline.update_buffer(
                &devices.device,
                &devices.device_context,
                &scene.shadows,
            )?;
        }

        if !scene.quads.is_empty() {
            self.pipelines.quad_pipeline.update_buffer(
                &devices.device,
                &devices.device_context,
                &scene.quads,
            )?;
        }

        if !scene.underlines.is_empty() {
            self.pipelines.underline_pipeline.update_buffer(
                &devices.device,
                &devices.device_context,
                &scene.underlines,
            )?;
        }

        if !scene.monochrome_sprites.is_empty() {
            self.pipelines.mono_sprites.update_buffer(
                &devices.device,
                &devices.device_context,
                &scene.monochrome_sprites,
            )?;
        }

        if !scene.subpixel_sprites.is_empty() {
            self.pipelines.subpixel_sprites.update_buffer(
                &devices.device,
                &devices.device_context,
                &scene.subpixel_sprites,
            )?;
        }

        if !scene.polychrome_sprites.is_empty() {
            self.pipelines.poly_sprites.update_buffer(
                &devices.device,
                &devices.device_context,
                &scene.polychrome_sprites,
            )?;
        }

        if !scene.custom.is_empty() {
            // The engine's encode, not a second one: the two renderers' fragments read the same
            // record, so it is built once, beside the type (`CustomRenderPrimitive::to_quad_record`).
            let instances: Vec<Quad> = scene
                .custom
                .iter()
                .map(CustomRenderPrimitive::to_quad_record)
                .collect();
            self.pipelines.imported_texture_pipeline.update_buffer(
                &devices.device,
                &devices.device_context,
                &instances,
            )?;
        }

        if !scene.surfaces.is_empty() {
            // The same record again, from the surface primitive: the geometry and the clip are the
            // quad path's, and `draw_surfaces` only supplies the view to sample
            // (`PaintSurface::to_quad_record`).
            let instances: Vec<Quad> = scene
                .surfaces
                .iter()
                .map(PaintSurface::to_quad_record)
                .collect();
            self.pipelines.surfaces_pipeline.update_buffer(
                &devices.device,
                &devices.device_context,
                &instances,
            )?;
        }

        Ok(())
    }

    fn draw_shadows(&mut self, start: usize, len: usize) -> Result<()> {
        if len == 0 {
            return Ok(());
        }
        let devices = self.devices.as_ref().context("devices missing")?;
        self.pipelines.shadow_pipeline.draw_range(
            &devices.device_context,
            self.globals
                .batch_params_buffer
                .as_ref()
                .context("batch params buffer missing")?,
            start as u32,
            len as u32,
        )
    }

    fn draw_quads(&mut self, start: usize, len: usize) -> Result<()> {
        if len == 0 {
            return Ok(());
        }
        let devices = self.devices.as_ref().context("devices missing")?;
        self.pipelines.quad_pipeline.draw_range(
            &devices.device_context,
            self.globals
                .batch_params_buffer
                .as_ref()
                .context("batch params buffer missing")?,
            start as u32,
            len as u32,
        )
    }

    fn draw_paths_to_intermediate(&mut self, paths: &[Path<ScaledPixels>]) -> Result<()> {
        if paths.is_empty() {
            return Ok(());
        }

        let devices = self.devices.as_ref().context("devices missing")?;
        let resources = self.resources.as_ref().context("resources missing")?;
        // Clear intermediate MSAA texture
        unsafe {
            devices.device_context.ClearRenderTargetView(
                resources.path_intermediate_msaa_view.as_ref().unwrap(),
                &[0.0; 4],
            );
            // Set intermediate MSAA texture as render target
            devices.device_context.OMSetRenderTargets(
                Some(slice::from_ref(&resources.path_intermediate_msaa_view)),
                None,
            );
        }

        // Collect all vertices and sprites for a single draw call
        let mut vertices = Vec::new();

        for path in paths {
            vertices.extend(path.vertices.iter().map(|v| PathRasterizationSprite {
                xy_position: v.xy_position,
                st_position: v.st_position,
                color: path.color,
                bounds: path.clipped_bounds(),
            }));
        }

        self.pipelines.path_rasterization_pipeline.update_buffer(
            &devices.device,
            &devices.device_context,
            &vertices,
        )?;

        self.pipelines.path_rasterization_pipeline.draw(
            &devices.device_context,
            D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
            vertices.len() as u32,
            1,
        )?;

        // Resolve MSAA to non-MSAA intermediate texture
        unsafe {
            devices.device_context.ResolveSubresource(
                &resources.path_intermediate_texture,
                0,
                &resources.path_intermediate_msaa_texture,
                0,
                RENDER_TARGET_FORMAT,
            );
            // Restore main render target
            devices
                .device_context
                .OMSetRenderTargets(Some(slice::from_ref(&resources.render_target_view)), None);
        }

        Ok(())
    }

    fn draw_paths_from_intermediate(&mut self, paths: &[Path<ScaledPixels>]) -> Result<()> {
        let Some(first_path) = paths.first() else {
            return Ok(());
        };

        // When copying paths from the intermediate texture to the drawable,
        // each pixel must only be copied once, in case of transparent paths.
        //
        // If all paths have the same draw order, then their bounds are all
        // disjoint, so we can copy each path's bounds individually. If this
        // batch combines different draw orders, we perform a single copy
        // for a minimal spanning rect.
        let sprites = if paths.last().unwrap().order == first_path.order {
            paths
                .iter()
                .map(|path| PathSprite {
                    bounds: path.clipped_bounds(),
                })
                .collect::<Vec<_>>()
        } else {
            let mut bounds = first_path.clipped_bounds();
            for path in paths.iter().skip(1) {
                bounds = bounds.union(&path.clipped_bounds());
            }
            vec![PathSprite { bounds }]
        };

        let devices = self.devices.as_ref().context("devices missing")?;
        let resources = self.resources.as_ref().context("resources missing")?;
        self.pipelines.path_sprite_pipeline.update_buffer(
            &devices.device,
            &devices.device_context,
            &sprites,
        )?;

        // Draw the sprites with the path texture
        self.pipelines.path_sprite_pipeline.draw_with_texture(
            &devices.device_context,
            slice::from_ref(&resources.path_intermediate_srv),
            slice::from_ref(&self.globals.sampler),
            sprites.len() as u32,
        )
    }

    fn draw_underlines(&mut self, start: usize, len: usize) -> Result<()> {
        if len == 0 {
            return Ok(());
        }
        let devices = self.devices.as_ref().context("devices missing")?;
        self.pipelines.underline_pipeline.draw_range(
            &devices.device_context,
            self.globals
                .batch_params_buffer
                .as_ref()
                .context("batch params buffer missing")?,
            start as u32,
            len as u32,
        )
    }

    fn draw_monochrome_sprites(
        &mut self,
        texture_id: AtlasTextureId,
        start: usize,
        len: usize,
    ) -> Result<()> {
        if len == 0 {
            return Ok(());
        }
        let devices = self.devices.as_ref().context("devices missing")?;
        let Some(texture_view) = self.atlas.get_texture_view(texture_id) else {
            return Ok(());
        };
        self.pipelines.mono_sprites.draw_range_with_texture(
            &devices.device_context,
            &texture_view,
            self.globals
                .batch_params_buffer
                .as_ref()
                .context("batch params buffer missing")?,
            slice::from_ref(&self.globals.sampler),
            start as u32,
            len as u32,
        )
    }

    fn draw_subpixel_sprites(
        &mut self,
        texture_id: AtlasTextureId,
        start: usize,
        len: usize,
    ) -> Result<()> {
        if len == 0 {
            return Ok(());
        }
        let devices = self.devices.as_ref().context("devices missing")?;
        let Some(texture_view) = self.atlas.get_texture_view(texture_id) else {
            return Ok(());
        };
        self.pipelines.subpixel_sprites.draw_range_with_texture(
            &devices.device_context,
            &texture_view,
            self.globals
                .batch_params_buffer
                .as_ref()
                .context("batch params buffer missing")?,
            slice::from_ref(&self.globals.sampler),
            start as u32,
            len as u32,
        )
    }

    fn draw_polychrome_sprites(
        &mut self,
        texture_id: AtlasTextureId,
        start: usize,
        len: usize,
    ) -> Result<()> {
        if len == 0 {
            return Ok(());
        }
        let devices = self.devices.as_ref().context("devices missing")?;
        let Some(texture_view) = self.atlas.get_texture_view(texture_id) else {
            return Ok(());
        };
        self.pipelines.poly_sprites.draw_range_with_texture(
            &devices.device_context,
            &texture_view,
            self.globals
                .batch_params_buffer
                .as_ref()
                .context("batch params buffer missing")?,
            slice::from_ref(&self.globals.sampler),
            start as u32,
            len as u32,
        )
    }

    fn draw_surfaces(&mut self, start: usize, surfaces: &[PaintSurface]) -> Result<()> {
        if surfaces.is_empty() {
            return Ok(());
        }

        // Resolve every surface to the view to sample before borrowing the device: the `Texture`
        // variant consults the view cache (a `&mut self` use) and the draws below only read.
        let views: Vec<Option<ID3D11ShaderResourceView>> = surfaces
            .iter()
            .map(|surface| self.surface_view(&surface.source))
            .collect();

        let devices = self.devices.as_ref().context("devices missing")?;
        let batch_params_buffer = self
            .globals
            .batch_params_buffer
            .as_ref()
            .context("batch params buffer missing")?;

        // One draw per surface: the view is the surface's own and the engine never names it, so
        // there is no batch to group beyond the record slice the encoding already shares — the
        // shape the imported-texture path takes, for the same reason.
        for (offset, view) in views.into_iter().enumerate() {
            let Some(view) = view else {
                continue;
            };

            // Fault softly, and for one frame only: a view that does not name a sampleable 2D
            // texture is dropped rather than allowed to fault the frame the rest of the UI is in.
            if !surface_view_is_sampleable(&view) {
                continue;
            }

            self.pipelines.surfaces_pipeline.draw_range_with_texture(
                &devices.device_context,
                slice::from_ref(&Some(view)),
                batch_params_buffer,
                slice::from_ref(&self.globals.imported_texture_sampler),
                (start + offset) as u32,
                1,
            )?;

            // Unbind immediately. The producer may write the resource again next frame, and a slot
            // kept bound after the draw is a hazard: the draw is what ordered the read, not the
            // binding.
            unsafe {
                devices
                    .device_context
                    .PSSetShaderResources(0, Some(&[None]));
            }
        }
        Ok(())
    }

    /// The view to sample for `source`, making one for the `Texture` variant the first time it is seen.
    ///
    /// A `View` variant already carries the producer's view, so it is used as it is. A `Texture` variant
    /// carries the texture instead — a producer that ships the resource and lets the renderer make
    /// the view, the same-device half of the rule the `View` variant states — so the renderer builds
    /// the view here, with `create_imported_texture_view`, the rules the imported-texture path
    /// already uses for format and usage.
    ///
    /// The `Texture` variant's views are cached, because a shader resource view is a descriptor with a
    /// GPU-side allocation: one per frame would be a cost the `View` variant never pays. The key is the
    /// texture's raw COM interface pointer (`Interface::as_raw`), which is stable across the clones
    /// a producer hands over frame to frame. It is a sound key because a cached view holds a
    /// reference to the resource it views, so while an entry is live the texture cannot be released
    /// and its pointer cannot be recycled by an unrelated texture: a hit always names the same live
    /// object.
    ///
    /// Invalidation and lifetime:
    /// - a replaced device makes every cached view invalid, so `handle_device_lost` clears the map;
    /// - [`Self::prune_surface_views`] drops an entry once no surface has named its texture for
    ///   [`SURFACE_VIEW_CACHE_PATIENCE`] frames. That drop is the only point that releases the last
    ///   reference to a texture the producer has already released; until then the renderer holds
    ///   it, exactly as any other view of it would.
    ///
    /// A texture the renderer cannot view — another device's, or a format the view rules refuse —
    /// is skipped for the frame rather than faulting the frame the rest of the UI shares, the same
    /// soft fault `surface_view_is_sampleable` makes.
    fn surface_view(&mut self, source: &SurfaceSource) -> Option<ID3D11ShaderResourceView> {
        let source = match source {
            SurfaceSource::DirectX(source) => source,
            // On a platform with no Direct3D surface backend, `SurfaceSource` is uninhabited here; the
            // arm it matches is the one every cfg of this renderer has.
            #[allow(unreachable_patterns)]
            _ => return None,
        };
        match source {
            DirectXSource::View(view) => Some(view.clone()),
            DirectXSource::Texture(texture) => {
                let key = texture.as_raw().addr();
                if let Some(entry) = self.surface_views.get_mut(&key) {
                    entry.last_used = self.frame_index;
                    return Some(entry.view.clone());
                }

                let device = self.devices.as_ref()?.device.clone();
                let view = match create_imported_texture_view(&device, texture) {
                    Ok(view) => view,
                    Err(error) => {
                        log::warn!(
                            "a surface's texture could not be viewed; skipping it: {error:#}"
                        );
                        return None;
                    }
                };
                self.surface_views.insert(
                    key,
                    SurfaceView {
                        view: view.clone(),
                        last_used: self.frame_index,
                    },
                );
                Some(view)
            }
            DirectXSource::Shared(shared) => self.shared_surface_view(shared),
        }
    }

    /// The view of a producer's shared texture, opening and viewing it on the renderer's device the
    /// first time it is seen, and ordering the producer's writes before the draw.
    ///
    /// The handle is device-independent, so the renderer makes the device-side objects — the texture
    /// `OpenSharedResource1` opens and the view of it — once, and caches them exactly as it caches a
    /// `Texture`-variant view: cleared on a device replacement, pruned once no surface has named the
    /// handle for [`SURFACE_VIEW_CACHE_PATIENCE`] frames. The fence is opened and cached the same
    /// way, and waited on the context that will draw, so the sample is ordered behind the producer's
    /// signal without a CPU poll.
    fn shared_surface_view(
        &mut self,
        shared: &SharedDirectXSurface,
    ) -> Option<ID3D11ShaderResourceView> {
        let key = shared.texture.0 as usize;

        let view = match self.shared_surfaces.get(&key) {
            Some(entry) => entry.view.clone(),
            None => {
                let device = self.devices.as_ref()?.device.clone();
                let (texture, view) = match open_shared_surface(&device, shared) {
                    Ok(opened) => opened,
                    Err(error) => {
                        log::warn!("a shared surface could not be opened; skipping it: {error:#}");
                        return None;
                    }
                };
                self.shared_surfaces.insert(
                    key,
                    SharedSurfaceView {
                        view: view.clone(),
                        _texture: texture,
                        last_used: self.frame_index,
                    },
                );
                view
            }
        };
        if let Some(entry) = self.shared_surfaces.get_mut(&key) {
            entry.last_used = self.frame_index;
        }

        if let Some(sync) = &shared.fence {
            let device = self.devices.as_ref()?.device.clone();
            let context = self.devices.as_ref()?.device_context.clone();
            match self.shared_fence(&device, sync.handle) {
                Ok(fence) => {
                    if let Err(error) = wait_for_fence(&context, &fence, sync.value) {
                        log::warn!("a shared surface's fence could not be waited on: {error:#}");
                    }
                }
                Err(error) => log::warn!("a shared surface's fence could not be opened: {error:#}"),
            }
        }

        Some(view)
    }

    /// The renderer's opened form of a producer's shared fence, opening and caching it the first
    /// time it is seen.
    fn shared_fence(&mut self, device: &ID3D11Device, handle: HANDLE) -> Result<ID3D11Fence> {
        let key = handle.0 as usize;
        if let Some(entry) = self.shared_fences.get_mut(&key) {
            entry.last_used = self.frame_index;
            return Ok(entry.fence.clone());
        }
        let fence = open_shared_fence(device, handle)?;
        self.shared_fences.insert(
            key,
            SharedFenceEntry {
                fence: fence.clone(),
                last_used: self.frame_index,
            },
        );
        Ok(fence)
    }

    /// Drops the surface views and shared-handle entries no surface has named for
    /// `SURFACE_VIEW_CACHE_PATIENCE` frames. Called once per frame, after the batches; see
    /// [`Self::surface_view`] for the rule.
    fn prune_surface_views(&mut self) {
        let frame = self.frame_index;
        let fresh = |last_used: u64| frame.saturating_sub(last_used) <= SURFACE_VIEW_CACHE_PATIENCE;
        self.surface_views.retain(|_, entry| fresh(entry.last_used));
        self.shared_surfaces
            .retain(|_, entry| fresh(entry.last_used));
        self.shared_fences.retain(|_, entry| fresh(entry.last_used));
    }

    fn draw_custom(&mut self, start: usize, customs: &[CustomRenderPrimitive]) -> Result<()> {
        if customs.is_empty() {
            return Ok(());
        }
        let devices = self.devices.as_ref().context("devices missing")?;

        // One draw per primitive: the texture is the primitive's own and the engine never names
        // it, so there is no batch to group beyond the record slice the encoding already shares.
        for (offset, custom) in customs.iter().enumerate() {
            let CustomRenderPrimitive::Texture { handle, .. } = custom;
            let Some(imported) = handle.payload.downcast_ref::<DirectXImportedTexture>() else {
                anyhow::bail!("an imported texture handle does not hold a Direct3D texture");
            };

            let view = create_imported_texture_view(&devices.device, &imported.texture)?;
            self.pipelines
                .imported_texture_pipeline
                .draw_range_with_texture(
                    &devices.device_context,
                    slice::from_ref(&Some(view)),
                    self.globals
                        .batch_params_buffer
                        .as_ref()
                        .context("batch params buffer missing")?,
                    slice::from_ref(&self.globals.imported_texture_sampler),
                    (start + offset) as u32,
                    1,
                )?;
        }
        Ok(())
    }

    pub(crate) fn gpu_specs(&self) -> Result<GpuSpecs> {
        let devices = self.devices.as_ref().context("devices missing")?;
        let desc = unsafe { devices.adapter.GetDesc1() }?;
        let is_software_emulated = (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE.0 as u32) != 0;
        let device_name = String::from_utf16_lossy(&desc.Description)
            .trim_matches(char::from(0))
            .to_string();
        let driver_name = match desc.VendorId {
            0x10DE => "NVIDIA Corporation".to_string(),
            0x1002 => "AMD Corporation".to_string(),
            0x8086 => "Intel Corporation".to_string(),
            id => format!("Unknown Vendor (ID: {:#X})", id),
        };
        let driver_version = match desc.VendorId {
            0x10DE => nvidia::get_driver_version(),
            0x1002 => amd::get_driver_version(),
            // For Intel and other vendors, we use the DXGI API to get the driver version.
            _ => dxgi::get_driver_version(&devices.adapter),
        }
        .context("Failed to get gpu driver info")
        .log_err()
        .unwrap_or("Unknown Driver".to_string());
        Ok(GpuSpecs {
            is_software_emulated,
            device_name,
            driver_name,
            driver_info: driver_version,
        })
    }

    pub(crate) fn get_font_info() -> &'static FontInfo {
        static CACHED_FONT_INFO: OnceLock<FontInfo> = OnceLock::new();
        CACHED_FONT_INFO.get_or_init(|| unsafe {
            let factory: IDWriteFactory5 = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED).unwrap();
            let render_params: IDWriteRenderingParams1 =
                factory.CreateRenderingParams().unwrap().cast().unwrap();
            FontInfo {
                gamma_ratios: get_gamma_correction_ratios(render_params.GetGamma()),
                grayscale_enhanced_contrast: render_params.GetGrayscaleEnhancedContrast(),
                subpixel_enhanced_contrast: render_params.GetEnhancedContrast(),
                is_bgr: render_params.GetPixelGeometry() == DWRITE_PIXEL_GEOMETRY_BGR,
            }
        })
    }

    pub(crate) fn mark_drawable(&mut self) {
        self.skip_draws = false;
    }
}

impl DirectXResources {
    pub fn new(
        devices: &DirectXRendererDevices,
        width: u32,
        height: u32,
        hwnd: HWND,
        disable_direct_composition: bool,
    ) -> Result<Self> {
        let swap_chain = if disable_direct_composition {
            create_swap_chain(&devices.dxgi_factory, &devices.device, hwnd, width, height)?
        } else {
            create_swap_chain_for_composition(
                &devices.dxgi_factory,
                &devices.device,
                width,
                height,
            )?
        };

        let (
            render_target,
            render_target_view,
            path_intermediate_texture,
            path_intermediate_srv,
            path_intermediate_msaa_texture,
            path_intermediate_msaa_view,
            viewport,
        ) = create_resources(devices, &swap_chain, width, height)?;
        set_rasterizer_state(&devices.device, &devices.device_context)?;

        Ok(Self {
            swap_chain,
            render_target: Some(render_target),
            render_target_view,
            path_intermediate_texture,
            path_intermediate_msaa_texture,
            path_intermediate_msaa_view,
            path_intermediate_srv,
            viewport,
        })
    }

    #[inline]
    fn recreate_resources(
        &mut self,
        devices: &DirectXRendererDevices,
        width: u32,
        height: u32,
    ) -> Result<()> {
        let (
            render_target,
            render_target_view,
            path_intermediate_texture,
            path_intermediate_srv,
            path_intermediate_msaa_texture,
            path_intermediate_msaa_view,
            viewport,
        ) = create_resources(devices, &self.swap_chain, width, height)?;
        self.render_target = Some(render_target);
        self.render_target_view = render_target_view;
        self.path_intermediate_texture = path_intermediate_texture;
        self.path_intermediate_msaa_texture = path_intermediate_msaa_texture;
        self.path_intermediate_msaa_view = path_intermediate_msaa_view;
        self.path_intermediate_srv = path_intermediate_srv;
        self.viewport = viewport;
        Ok(())
    }
}

impl DirectXRenderPipelines {
    pub fn new(device: &ID3D11Device) -> Result<Self> {
        let shadow_pipeline = PipelineState::new(
            device,
            "shadow_pipeline",
            ShaderModule::Shadow,
            4,
            create_blend_state(device)?,
        )?;
        let quad_pipeline = PipelineState::new(
            device,
            "quad_pipeline",
            ShaderModule::Quad,
            64,
            create_blend_state(device)?,
        )?;
        let path_rasterization_pipeline = PipelineState::new(
            device,
            "path_rasterization_pipeline",
            ShaderModule::PathRasterization,
            32,
            create_blend_state_for_path_rasterization(device)?,
        )?;
        let path_sprite_pipeline = PipelineState::new(
            device,
            "path_sprite_pipeline",
            ShaderModule::PathSprite,
            4,
            create_blend_state_for_path_sprite(device)?,
        )?;
        let underline_pipeline = PipelineState::new(
            device,
            "underline_pipeline",
            ShaderModule::Underline,
            4,
            create_blend_state(device)?,
        )?;
        let mono_sprites = PipelineState::new(
            device,
            "monochrome_sprite_pipeline",
            ShaderModule::MonochromeSprite,
            512,
            create_blend_state(device)?,
        )?;
        let subpixel_sprites = PipelineState::new(
            device,
            "subpixel_sprite_pipeline",
            ShaderModule::SubpixelSprite,
            512,
            create_blend_state_for_subpixel_rendering(device)?,
        )?;
        let poly_sprites = PipelineState::new(
            device,
            "polychrome_sprite_pipeline",
            ShaderModule::PolychromeSprite,
            16,
            create_blend_state(device)?,
        )?;
        let imported_texture_pipeline = PipelineState::new(
            device,
            "imported_texture_pipeline",
            ShaderModule::ImportedTexture,
            64,
            create_blend_state(device)?,
        )?;
        let surfaces_pipeline = PipelineState::new(
            device,
            "surfaces_pipeline",
            ShaderModule::ImportedTexture,
            64,
            create_blend_state(device)?,
        )?;

        Ok(Self {
            shadow_pipeline,
            quad_pipeline,
            path_rasterization_pipeline,
            path_sprite_pipeline,
            underline_pipeline,
            mono_sprites,
            subpixel_sprites,
            poly_sprites,
            imported_texture_pipeline,
            surfaces_pipeline,
        })
    }
}

impl DirectComposition {
    pub fn new(dxgi_device: &IDXGIDevice, hwnd: HWND) -> Result<Self> {
        let comp_device = get_comp_device(dxgi_device)?;
        let comp_target = unsafe { comp_device.CreateTargetForHwnd(hwnd, true) }?;
        let comp_visual = unsafe { comp_device.CreateVisual() }?;

        Ok(Self {
            comp_device,
            comp_target,
            comp_visual,
        })
    }

    pub fn set_swap_chain(&self, swap_chain: &IDXGISwapChain1) -> Result<()> {
        unsafe {
            self.comp_visual.SetContent(swap_chain)?;
            self.comp_target.SetRoot(&self.comp_visual)?;
            self.comp_device.Commit()?;
        }
        Ok(())
    }
}

impl DirectXGlobalElements {
    pub fn new(device: &ID3D11Device) -> Result<Self> {
        let global_params_buffer = create_constant_buffer::<GlobalParams>(device)?;
        let batch_params_buffer = create_constant_buffer::<BatchParams>(device)?;

        let sampler = unsafe {
            let desc = D3D11_SAMPLER_DESC {
                Filter: D3D11_FILTER_MIN_MAG_MIP_LINEAR,
                AddressU: D3D11_TEXTURE_ADDRESS_WRAP,
                AddressV: D3D11_TEXTURE_ADDRESS_WRAP,
                AddressW: D3D11_TEXTURE_ADDRESS_WRAP,
                MipLODBias: 0.0,
                MaxAnisotropy: 1,
                ComparisonFunc: D3D11_COMPARISON_ALWAYS,
                BorderColor: [0.0; 4],
                MinLOD: 0.0,
                MaxLOD: D3D11_FLOAT32_MAX,
            };
            let mut output = None;
            device.CreateSamplerState(&desc, Some(&mut output))?;
            output
        };

        let imported_texture_sampler = unsafe {
            let desc = D3D11_SAMPLER_DESC {
                Filter: D3D11_FILTER_MIN_MAG_MIP_LINEAR,
                AddressU: D3D11_TEXTURE_ADDRESS_CLAMP,
                AddressV: D3D11_TEXTURE_ADDRESS_CLAMP,
                AddressW: D3D11_TEXTURE_ADDRESS_CLAMP,
                MipLODBias: 0.0,
                MaxAnisotropy: 1,
                ComparisonFunc: D3D11_COMPARISON_ALWAYS,
                BorderColor: [0.0; 4],
                MinLOD: 0.0,
                MaxLOD: D3D11_FLOAT32_MAX,
            };
            let mut output = None;
            device.CreateSamplerState(&desc, Some(&mut output))?;
            output
        };

        Ok(Self {
            global_params_buffer,
            batch_params_buffer,
            sampler,
            imported_texture_sampler,
        })
    }
}

#[derive(Debug, Default)]
#[repr(C)]
struct GlobalParams {
    gamma_ratios: [f32; 4],
    viewport_size: [f32; 2],
    grayscale_enhanced_contrast: f32,
    subpixel_enhanced_contrast: f32,
    is_bgr: u32,
    _pad: [u32; 3],
}

#[derive(Clone, Copy, Debug, Default)]
#[repr(C, align(16))]
struct BatchParams {
    start_index: u32,
    _padding: [u32; 3],
}

const _: () = assert!(std::mem::size_of::<BatchParams>() == 16);

struct PipelineState<T> {
    label: &'static str,
    vertex: ID3D11VertexShader,
    fragment: ID3D11PixelShader,
    buffer: ID3D11Buffer,
    buffer_size: usize,
    view: Option<ID3D11ShaderResourceView>,
    blend_state: ID3D11BlendState,
    _marker: std::marker::PhantomData<T>,
}

impl<T> PipelineState<T> {
    fn new(
        device: &ID3D11Device,
        label: &'static str,
        shader_module: ShaderModule,
        buffer_size: usize,
        blend_state: ID3D11BlendState,
    ) -> Result<Self> {
        let vertex = {
            let raw_shader = RawShaderBytes::new(shader_module, ShaderTarget::Vertex)?;
            create_vertex_shader(device, raw_shader.as_bytes())?
        };
        let fragment = {
            let raw_shader = RawShaderBytes::new(shader_module, ShaderTarget::Fragment)?;
            create_fragment_shader(device, raw_shader.as_bytes())?
        };
        let buffer = create_buffer(device, std::mem::size_of::<T>(), buffer_size)?;
        let view = create_buffer_view(device, &buffer)?;

        Ok(PipelineState {
            label,
            vertex,
            fragment,
            buffer,
            buffer_size,
            view,
            blend_state,
            _marker: std::marker::PhantomData,
        })
    }

    fn update_buffer(
        &mut self,
        device: &ID3D11Device,
        device_context: &ID3D11DeviceContext,
        data: &[T],
    ) -> Result<()> {
        if self.buffer_size < data.len() {
            let element_size = std::mem::size_of::<T>();
            let required_size = std::mem::size_of_val(data);
            anyhow::ensure!(
                required_size <= MAX_INSTANCE_BUFFER_SIZE,
                "{} buffer needs {required_size} bytes, above the maximum of {MAX_INSTANCE_BUFFER_SIZE}",
                self.label
            );
            let new_buffer_size = data
                .len()
                .next_power_of_two()
                .min(MAX_INSTANCE_BUFFER_SIZE / element_size);
            log::debug!(
                "Updating {} buffer size from {} to {}",
                self.label,
                self.buffer_size,
                new_buffer_size
            );
            let buffer = create_buffer(device, std::mem::size_of::<T>(), new_buffer_size)?;
            let view = create_buffer_view(device, &buffer)?;
            self.buffer = buffer;
            self.view = view;
            self.buffer_size = new_buffer_size;
        }
        update_buffer(device_context, &self.buffer, data)
    }

    fn draw(
        &self,
        device_context: &ID3D11DeviceContext,
        topology: D3D_PRIMITIVE_TOPOLOGY,
        vertex_count: u32,
        instance_count: u32,
    ) -> Result<()> {
        set_pipeline_state(
            device_context,
            slice::from_ref(&self.view),
            topology,
            &self.vertex,
            &self.fragment,
            &self.blend_state,
        );
        unsafe {
            device_context.DrawInstanced(vertex_count, instance_count, 0, 0);
        }
        Ok(())
    }

    fn draw_with_texture(
        &self,
        device_context: &ID3D11DeviceContext,
        texture: &[Option<ID3D11ShaderResourceView>],
        sampler: &[Option<ID3D11SamplerState>],
        instance_count: u32,
    ) -> Result<()> {
        set_pipeline_state(
            device_context,
            slice::from_ref(&self.view),
            D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
            &self.vertex,
            &self.fragment,
            &self.blend_state,
        );
        unsafe {
            device_context.PSSetSamplers(0, Some(sampler));
            device_context.VSSetShaderResources(0, Some(texture));
            device_context.PSSetShaderResources(0, Some(texture));

            device_context.DrawInstanced(4, instance_count, 0, 0);
        }
        Ok(())
    }

    fn draw_range(
        &self,
        device_context: &ID3D11DeviceContext,
        batch_params_buffer: &ID3D11Buffer,
        first_instance: u32,
        instance_count: u32,
    ) -> Result<()> {
        anyhow::ensure!(
            first_instance as usize + instance_count as usize <= self.buffer_size,
            "DirectX instance range exceeds the {} buffer",
            self.label
        );
        update_batch_start(device_context, batch_params_buffer, first_instance)?;
        set_pipeline_state(
            device_context,
            slice::from_ref(&self.view),
            D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
            &self.vertex,
            &self.fragment,
            &self.blend_state,
        );
        unsafe {
            device_context.DrawInstanced(4, instance_count, 0, 0);
        }
        Ok(())
    }

    fn draw_range_with_texture(
        &self,
        device_context: &ID3D11DeviceContext,
        texture: &[Option<ID3D11ShaderResourceView>],
        batch_params_buffer: &ID3D11Buffer,
        sampler: &[Option<ID3D11SamplerState>],
        first_instance: u32,
        instance_count: u32,
    ) -> Result<()> {
        anyhow::ensure!(
            first_instance as usize + instance_count as usize <= self.buffer_size,
            "DirectX instance range exceeds the {} buffer",
            self.label
        );
        update_batch_start(device_context, batch_params_buffer, first_instance)?;
        set_pipeline_state(
            device_context,
            slice::from_ref(&self.view),
            D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
            &self.vertex,
            &self.fragment,
            &self.blend_state,
        );
        unsafe {
            device_context.PSSetSamplers(0, Some(sampler));
            device_context.VSSetShaderResources(0, Some(texture));
            device_context.PSSetShaderResources(0, Some(texture));
            device_context.DrawInstanced(4, instance_count, 0, 0);
        }
        Ok(())
    }
}

#[derive(Clone, Copy)]
#[repr(C)]
struct PathRasterizationSprite {
    xy_position: Point<ScaledPixels>,
    st_position: Point<f32>,
    color: Background,
    bounds: Bounds<ScaledPixels>,
}

#[derive(Clone, Copy)]
#[repr(C)]
struct PathSprite {
    bounds: Bounds<ScaledPixels>,
}

impl Drop for DirectXRenderer {
    fn drop(&mut self) {
        #[cfg(debug_assertions)]
        if let Some(devices) = &self.devices {
            report_live_objects(&devices.device).ok();
        }
    }
}

#[inline]
fn get_comp_device(dxgi_device: &IDXGIDevice) -> Result<IDCompositionDevice> {
    Ok(unsafe { DCompositionCreateDevice(dxgi_device)? })
}

fn create_swap_chain_for_composition(
    dxgi_factory: &IDXGIFactory6,
    device: &ID3D11Device,
    width: u32,
    height: u32,
) -> Result<IDXGISwapChain1> {
    let desc = DXGI_SWAP_CHAIN_DESC1 {
        Width: width,
        Height: height,
        Format: RENDER_TARGET_FORMAT,
        Stereo: false.into(),
        SampleDesc: DXGI_SAMPLE_DESC {
            Count: 1,
            Quality: 0,
        },
        BufferUsage: DXGI_USAGE_RENDER_TARGET_OUTPUT,
        BufferCount: BUFFER_COUNT as u32,
        // Composition SwapChains only support the DXGI_SCALING_STRETCH Scaling.
        Scaling: DXGI_SCALING_STRETCH,
        SwapEffect: DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL,
        AlphaMode: DXGI_ALPHA_MODE_PREMULTIPLIED,
        Flags: 0,
    };
    Ok(unsafe { dxgi_factory.CreateSwapChainForComposition(device, &desc, None)? })
}

fn create_swap_chain(
    dxgi_factory: &IDXGIFactory6,
    device: &ID3D11Device,
    hwnd: HWND,
    width: u32,
    height: u32,
) -> Result<IDXGISwapChain1> {
    use windows::Win32::Graphics::Dxgi::DXGI_MWA_NO_ALT_ENTER;

    let desc = DXGI_SWAP_CHAIN_DESC1 {
        Width: width,
        Height: height,
        Format: RENDER_TARGET_FORMAT,
        Stereo: false.into(),
        SampleDesc: DXGI_SAMPLE_DESC {
            Count: 1,
            Quality: 0,
        },
        BufferUsage: DXGI_USAGE_RENDER_TARGET_OUTPUT,
        BufferCount: BUFFER_COUNT as u32,
        Scaling: DXGI_SCALING_NONE,
        SwapEffect: DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL,
        AlphaMode: DXGI_ALPHA_MODE_IGNORE,
        Flags: 0,
    };
    let swap_chain =
        unsafe { dxgi_factory.CreateSwapChainForHwnd(device, hwnd, &desc, None, None) }?;
    unsafe { dxgi_factory.MakeWindowAssociation(hwnd, DXGI_MWA_NO_ALT_ENTER) }?;
    Ok(swap_chain)
}

#[inline]
fn create_resources(
    devices: &DirectXRendererDevices,
    swap_chain: &IDXGISwapChain1,
    width: u32,
    height: u32,
) -> Result<(
    ID3D11Texture2D,
    Option<ID3D11RenderTargetView>,
    ID3D11Texture2D,
    Option<ID3D11ShaderResourceView>,
    ID3D11Texture2D,
    Option<ID3D11RenderTargetView>,
    D3D11_VIEWPORT,
)> {
    let (render_target, render_target_view) =
        create_render_target_and_its_view(swap_chain, &devices.device)?;
    let (path_intermediate_texture, path_intermediate_srv) =
        create_path_intermediate_texture(&devices.device, width, height)?;
    let (path_intermediate_msaa_texture, path_intermediate_msaa_view) =
        create_path_intermediate_msaa_texture_and_view(&devices.device, width, height)?;
    let viewport = D3D11_VIEWPORT {
        TopLeftX: 0.0,
        TopLeftY: 0.0,
        Width: width as f32,
        Height: height as f32,
        MinDepth: 0.0,
        MaxDepth: 1.0,
    };
    Ok((
        render_target,
        render_target_view,
        path_intermediate_texture,
        path_intermediate_srv,
        path_intermediate_msaa_texture,
        path_intermediate_msaa_view,
        viewport,
    ))
}

#[inline]
fn create_render_target_and_its_view(
    swap_chain: &IDXGISwapChain1,
    device: &ID3D11Device,
) -> Result<(ID3D11Texture2D, Option<ID3D11RenderTargetView>)> {
    let render_target: ID3D11Texture2D = unsafe { swap_chain.GetBuffer(0) }?;
    let mut render_target_view = None;
    unsafe { device.CreateRenderTargetView(&render_target, None, Some(&mut render_target_view))? };
    Ok((render_target, render_target_view))
}

#[inline]
fn create_path_intermediate_texture(
    device: &ID3D11Device,
    width: u32,
    height: u32,
) -> Result<(ID3D11Texture2D, Option<ID3D11ShaderResourceView>)> {
    let texture = unsafe {
        let mut output = None;
        let desc = D3D11_TEXTURE2D_DESC {
            Width: width,
            Height: height,
            MipLevels: 1,
            ArraySize: 1,
            Format: RENDER_TARGET_FORMAT,
            SampleDesc: DXGI_SAMPLE_DESC {
                Count: 1,
                Quality: 0,
            },
            Usage: D3D11_USAGE_DEFAULT,
            BindFlags: (D3D11_BIND_RENDER_TARGET.0 | D3D11_BIND_SHADER_RESOURCE.0) as u32,
            CPUAccessFlags: 0,
            MiscFlags: 0,
        };
        device.CreateTexture2D(&desc, None, Some(&mut output))?;
        output.unwrap()
    };

    let mut shader_resource_view = None;
    unsafe { device.CreateShaderResourceView(&texture, None, Some(&mut shader_resource_view))? };

    Ok((texture, Some(shader_resource_view.unwrap())))
}

#[inline]
fn create_path_intermediate_msaa_texture_and_view(
    device: &ID3D11Device,
    width: u32,
    height: u32,
) -> Result<(ID3D11Texture2D, Option<ID3D11RenderTargetView>)> {
    let msaa_texture = unsafe {
        let mut output = None;
        let desc = D3D11_TEXTURE2D_DESC {
            Width: width,
            Height: height,
            MipLevels: 1,
            ArraySize: 1,
            Format: RENDER_TARGET_FORMAT,
            SampleDesc: DXGI_SAMPLE_DESC {
                Count: PATH_MULTISAMPLE_COUNT,
                Quality: D3D11_STANDARD_MULTISAMPLE_PATTERN.0 as u32,
            },
            Usage: D3D11_USAGE_DEFAULT,
            BindFlags: D3D11_BIND_RENDER_TARGET.0 as u32,
            CPUAccessFlags: 0,
            MiscFlags: 0,
        };
        device.CreateTexture2D(&desc, None, Some(&mut output))?;
        output.unwrap()
    };
    let mut msaa_view = None;
    unsafe { device.CreateRenderTargetView(&msaa_texture, None, Some(&mut msaa_view))? };
    Ok((msaa_texture, Some(msaa_view.unwrap())))
}

#[inline]
fn set_rasterizer_state(device: &ID3D11Device, device_context: &ID3D11DeviceContext) -> Result<()> {
    let desc = D3D11_RASTERIZER_DESC {
        FillMode: D3D11_FILL_SOLID,
        CullMode: D3D11_CULL_NONE,
        FrontCounterClockwise: false.into(),
        DepthBias: 0,
        DepthBiasClamp: 0.0,
        SlopeScaledDepthBias: 0.0,
        DepthClipEnable: true.into(),
        ScissorEnable: false.into(),
        MultisampleEnable: true.into(),
        AntialiasedLineEnable: false.into(),
    };
    let rasterizer_state = unsafe {
        let mut state = None;
        device.CreateRasterizerState(&desc, Some(&mut state))?;
        state.unwrap()
    };
    unsafe { device_context.RSSetState(&rasterizer_state) };
    Ok(())
}

// https://learn.microsoft.com/en-us/windows/win32/api/d3d11/ns-d3d11-d3d11_blend_desc
#[inline]
fn create_blend_state(device: &ID3D11Device) -> Result<ID3D11BlendState> {
    let mut desc = D3D11_BLEND_DESC::default();
    desc.RenderTarget[0].BlendEnable = true.into();
    desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
    desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
    desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
    desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
    desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
    desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ONE;
    desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8;
    unsafe {
        let mut state = None;
        device.CreateBlendState(&desc, Some(&mut state))?;
        Ok(state.unwrap())
    }
}

#[inline]
fn create_blend_state_for_subpixel_rendering(device: &ID3D11Device) -> Result<ID3D11BlendState> {
    let mut desc = D3D11_BLEND_DESC::default();
    desc.RenderTarget[0].BlendEnable = true.into();
    desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
    desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
    desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC1_COLOR;
    desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC1_COLOR;
    // It does not make sense to draw transparent subpixel-rendered text, since it cannot be meaningfully alpha-blended onto anything else.
    desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
    desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
    desc.RenderTarget[0].RenderTargetWriteMask =
        D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8 & !D3D11_COLOR_WRITE_ENABLE_ALPHA.0 as u8;

    unsafe {
        let mut state = None;
        device.CreateBlendState(&desc, Some(&mut state))?;
        Ok(state.unwrap())
    }
}

#[inline]
fn create_blend_state_for_path_rasterization(device: &ID3D11Device) -> Result<ID3D11BlendState> {
    // If the feature level is set to greater than D3D_FEATURE_LEVEL_9_3, the display
    // device performs the blend in linear space, which is ideal.
    let mut desc = D3D11_BLEND_DESC::default();
    desc.RenderTarget[0].BlendEnable = true.into();
    desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
    desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
    desc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
    desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
    desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
    desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
    desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8;
    unsafe {
        let mut state = None;
        device.CreateBlendState(&desc, Some(&mut state))?;
        Ok(state.unwrap())
    }
}

#[inline]
fn create_blend_state_for_path_sprite(device: &ID3D11Device) -> Result<ID3D11BlendState> {
    // If the feature level is set to greater than D3D_FEATURE_LEVEL_9_3, the display
    // device performs the blend in linear space, which is ideal.
    let mut desc = D3D11_BLEND_DESC::default();
    desc.RenderTarget[0].BlendEnable = true.into();
    desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
    desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
    desc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
    desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
    desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
    desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ONE;
    desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8;
    unsafe {
        let mut state = None;
        device.CreateBlendState(&desc, Some(&mut state))?;
        Ok(state.unwrap())
    }
}

#[inline]
fn create_vertex_shader(device: &ID3D11Device, bytes: &[u8]) -> Result<ID3D11VertexShader> {
    unsafe {
        let mut shader = None;
        device.CreateVertexShader(bytes, None, Some(&mut shader))?;
        Ok(shader.unwrap())
    }
}

#[inline]
fn create_fragment_shader(device: &ID3D11Device, bytes: &[u8]) -> Result<ID3D11PixelShader> {
    unsafe {
        let mut shader = None;
        device.CreatePixelShader(bytes, None, Some(&mut shader))?;
        Ok(shader.unwrap())
    }
}

/// The producer's texture, viewed for the imported-texture fragment.
///
/// The view is the resource's *non-sRGB* counterpart rather than its sRGB one, which is what
/// makes the sample the bytes the producer wrote: the target is the non-sRGB `_UNORM` the atlas
/// is in, and this renderer's shaders work on sRGB-encoded values there directly, so a decode
/// here would leave the fragment a transfer function to cancel — and the only one this shader
/// file has is the ≈2.2 approximation, which does not round-trip exactly.
///
/// A texture from another device fails here rather than composing silently: `D3D11` resolves a
/// resource through the device that made it.
/// Open a producer's shared texture on the renderer's device and make its view.
///
/// The Direct3D counterpart of importing a dma-buf: the handle is device-independent, so the
/// renderer makes the device-side objects — the texture `OpenSharedResource1` opens and the view of
/// it — on the device it draws with. `create_imported_texture_view` applies the same format and
/// usage rules the same-device `Texture` variant uses.
fn open_shared_surface(
    device: &ID3D11Device,
    shared: &SharedDirectXSurface,
) -> Result<(ID3D11Texture2D, ID3D11ShaderResourceView)> {
    let device1: ID3D11Device1 = device
        .cast()
        .context("the device is not a Direct3D 11.1 device")?;
    // SAFETY: `shared.texture` names a live shared resource, and the returned texture and view are
    // owned by the caller.
    unsafe {
        let texture: ID3D11Texture2D = device1
            .OpenSharedResource1(shared.texture)
            .context("opening the producer's shared texture")?;
        let view = create_imported_texture_view(device, &texture)?;
        Ok((texture, view))
    }
}

/// Open a producer's shared fence on the renderer's device.
fn open_shared_fence(device: &ID3D11Device, handle: HANDLE) -> Result<ID3D11Fence> {
    let device5: ID3D11Device5 = device
        .cast()
        .context("the device is not a Direct3D 11.5 device")?;
    // SAFETY: `handle` names a live shared fence, and the opened fence is returned to the caller.
    unsafe {
        let mut fence = None;
        device5
            .OpenSharedFence(handle, &mut fence)
            .context("opening the producer's shared fence")?;
        fence.context("OpenSharedFence returned no fence")
    }
}

/// Insert a GPU-side wait for `fence` to reach `value`, on the context that will draw the surface.
fn wait_for_fence(context: &ID3D11DeviceContext, fence: &ID3D11Fence, value: u64) -> Result<()> {
    // SAFETY: `context` and `fence` are live, and the wait is GPU-side rather than a CPU poll.
    unsafe {
        let context4: ID3D11DeviceContext4 = context
            .cast()
            .context("the context is not a Direct3D 11.4 context")?;
        context4
            .Wait(fence, value)
            .context("waiting for the producer's shared fence")?;
    }
    Ok(())
}

/// Whether a surface's view names a 2D texture the fragment can sample.
///
/// The renderer did not make this view — a producer did — so the checks it would make while
/// building one happen here, at the draw, and a view that fails is skipped for the frame rather
/// than allowed to fault the frame the rest of the UI shares.
fn surface_view_is_sampleable(view: &ID3D11ShaderResourceView) -> bool {
    unsafe {
        let Ok(resource) = view.GetResource() else {
            return false;
        };
        let Ok(texture) = resource.cast::<ID3D11Texture2D>() else {
            return false;
        };
        let mut desc = D3D11_TEXTURE2D_DESC::default();
        texture.GetDesc(&mut desc);
        desc.Width > 0 && desc.Height > 0
    }
}

/// The producer's texture, viewed with the target's own channel order.
///
/// `CreateShaderResourceView` may only re-interpret a resource within its own format family, so a
/// texture whose channel order is the other way round — `R8G8B8A8` where the target is `B8G8R8A8`
/// — is refused here rather than left to Direct3D. Direct3D's own refusal is not guaranteed, and
/// where it does not come the view is made, the fragment writes the sample straight through, and
/// the frame composites the wrong image with red and blue exchanged instead of failing. Refusing
/// it here is what turns the `Texture` variant's wrong-format texture into the same skip-with-a-reason
/// `surface_view` already gives a texture it cannot view.
#[inline]
fn create_imported_texture_view(
    device: &ID3D11Device,
    texture: &ID3D11Texture2D,
) -> Result<ID3D11ShaderResourceView> {
    let texture_desc = unsafe {
        let mut desc = D3D11_TEXTURE2D_DESC::default();
        texture.GetDesc(&mut desc);
        desc
    };
    anyhow::ensure!(
        matches!(
            texture_desc.Format,
            DXGI_FORMAT_B8G8R8A8_UNORM | DXGI_FORMAT_B8G8R8A8_UNORM_SRGB
        ),
        "a texture the renderer views must be B8G8R8A8, the channel order the Direct3D target is \
         in, but this one is {:?}",
        texture_desc.Format
    );

    let desc = D3D11_SHADER_RESOURCE_VIEW_DESC {
        Format: DXGI_FORMAT_B8G8R8A8_UNORM,
        ViewDimension: D3D_SRV_DIMENSION_TEXTURE2D,
        Anonymous: D3D11_SHADER_RESOURCE_VIEW_DESC_0 {
            Texture2D: D3D11_TEX2D_SRV {
                MostDetailedMip: 0,
                MipLevels: 1,
            },
        },
    };
    let mut view = None;
    unsafe { device.CreateShaderResourceView(texture, Some(&desc), Some(&mut view))? };
    view.context("CreateShaderResourceView returned no view")
}

#[inline]
fn create_constant_buffer<T>(device: &ID3D11Device) -> Result<Option<ID3D11Buffer>> {
    const { assert!(std::mem::size_of::<T>() != 0 && std::mem::size_of::<T>().is_multiple_of(16)) };
    let desc = D3D11_BUFFER_DESC {
        ByteWidth: std::mem::size_of::<T>() as u32,
        Usage: D3D11_USAGE_DYNAMIC,
        BindFlags: D3D11_BIND_CONSTANT_BUFFER.0 as u32,
        CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32,
        MiscFlags: 0,
        StructureByteStride: 0,
    };
    let mut buffer = None;
    unsafe { device.CreateBuffer(&desc, None, Some(&mut buffer)) }?;
    Ok(buffer)
}

#[inline]
fn create_buffer(
    device: &ID3D11Device,
    element_size: usize,
    buffer_size: usize,
) -> Result<ID3D11Buffer> {
    let desc = D3D11_BUFFER_DESC {
        ByteWidth: (element_size * buffer_size) as u32,
        Usage: D3D11_USAGE_DYNAMIC,
        BindFlags: D3D11_BIND_SHADER_RESOURCE.0 as u32,
        CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32,
        MiscFlags: D3D11_RESOURCE_MISC_BUFFER_STRUCTURED.0 as u32,
        StructureByteStride: element_size as u32,
    };
    let mut buffer = None;
    unsafe { device.CreateBuffer(&desc, None, Some(&mut buffer)) }?;
    Ok(buffer.unwrap())
}

#[inline]
fn create_buffer_view(
    device: &ID3D11Device,
    buffer: &ID3D11Buffer,
) -> Result<Option<ID3D11ShaderResourceView>> {
    let mut view = None;
    unsafe { device.CreateShaderResourceView(buffer, None, Some(&mut view)) }?;
    Ok(view)
}

#[inline]
fn update_buffer<T>(
    device_context: &ID3D11DeviceContext,
    buffer: &ID3D11Buffer,
    data: &[T],
) -> Result<()> {
    unsafe {
        let mut dest = std::mem::zeroed();
        device_context.Map(buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, Some(&mut dest))?;
        std::ptr::copy_nonoverlapping(data.as_ptr(), dest.pData as _, data.len());
        device_context.Unmap(buffer, 0);
    }
    Ok(())
}

#[inline]
fn update_batch_start(
    device_context: &ID3D11DeviceContext,
    buffer: &ID3D11Buffer,
    first_instance: u32,
) -> Result<()> {
    update_buffer(
        device_context,
        buffer,
        &[BatchParams {
            start_index: first_instance,
            _padding: [0; 3],
        }],
    )
}

#[inline]
fn set_pipeline_state(
    device_context: &ID3D11DeviceContext,
    buffer_view: &[Option<ID3D11ShaderResourceView>],
    topology: D3D_PRIMITIVE_TOPOLOGY,
    vertex_shader: &ID3D11VertexShader,
    fragment_shader: &ID3D11PixelShader,
    blend_state: &ID3D11BlendState,
) {
    unsafe {
        device_context.VSSetShaderResources(1, Some(buffer_view));
        device_context.PSSetShaderResources(1, Some(buffer_view));
        device_context.IASetPrimitiveTopology(topology);
        device_context.VSSetShader(vertex_shader, None);
        device_context.PSSetShader(fragment_shader, None);
        device_context.OMSetBlendState(blend_state, None, 0xFFFFFFFF);
    }
}

#[cfg(debug_assertions)]
fn report_live_objects(device: &ID3D11Device) -> Result<()> {
    let debug_device: ID3D11Debug = device.cast()?;
    unsafe {
        debug_device.ReportLiveDeviceObjects(D3D11_RLDO_DETAIL)?;
    }
    Ok(())
}

const BUFFER_COUNT: usize = 3;

pub(crate) mod shader_resources {
    use anyhow::Result;

    #[cfg(debug_assertions)]
    use windows::{
        Win32::Graphics::Direct3D::{
            Fxc::{D3DCOMPILE_DEBUG, D3DCOMPILE_SKIP_OPTIMIZATION, D3DCompileFromFile},
            ID3DBlob,
        },
        core::{HSTRING, PCSTR},
    };

    #[derive(Copy, Clone, Debug, Eq, PartialEq)]
    pub(crate) enum ShaderModule {
        Quad,
        Shadow,
        Underline,
        PathRasterization,
        PathSprite,
        MonochromeSprite,
        SubpixelSprite,
        PolychromeSprite,
        ImportedTexture,
        EmojiRasterization,
    }

    #[derive(Copy, Clone, Debug, Eq, PartialEq)]
    pub(crate) enum ShaderTarget {
        Vertex,
        Fragment,
    }

    pub(crate) struct RawShaderBytes<'t> {
        inner: &'t [u8],

        #[cfg(debug_assertions)]
        _blob: ID3DBlob,
    }

    impl<'t> RawShaderBytes<'t> {
        pub(crate) fn new(module: ShaderModule, target: ShaderTarget) -> Result<Self> {
            #[cfg(not(debug_assertions))]
            {
                Ok(Self::from_bytes(module, target))
            }
            #[cfg(debug_assertions)]
            {
                let blob = build_shader_blob(module, target)?;
                let inner = unsafe {
                    std::slice::from_raw_parts(
                        blob.GetBufferPointer() as *const u8,
                        blob.GetBufferSize(),
                    )
                };
                Ok(Self { inner, _blob: blob })
            }
        }

        pub(crate) fn as_bytes(&'t self) -> &'t [u8] {
            self.inner
        }

        #[cfg(not(debug_assertions))]
        fn from_bytes(module: ShaderModule, target: ShaderTarget) -> Self {
            let bytes = match module {
                ShaderModule::Quad => match target {
                    ShaderTarget::Vertex => QUAD_VERTEX_BYTES,
                    ShaderTarget::Fragment => QUAD_FRAGMENT_BYTES,
                },
                ShaderModule::Shadow => match target {
                    ShaderTarget::Vertex => SHADOW_VERTEX_BYTES,
                    ShaderTarget::Fragment => SHADOW_FRAGMENT_BYTES,
                },
                ShaderModule::Underline => match target {
                    ShaderTarget::Vertex => UNDERLINE_VERTEX_BYTES,
                    ShaderTarget::Fragment => UNDERLINE_FRAGMENT_BYTES,
                },
                ShaderModule::PathRasterization => match target {
                    ShaderTarget::Vertex => PATH_RASTERIZATION_VERTEX_BYTES,
                    ShaderTarget::Fragment => PATH_RASTERIZATION_FRAGMENT_BYTES,
                },
                ShaderModule::PathSprite => match target {
                    ShaderTarget::Vertex => PATH_SPRITE_VERTEX_BYTES,
                    ShaderTarget::Fragment => PATH_SPRITE_FRAGMENT_BYTES,
                },
                ShaderModule::MonochromeSprite => match target {
                    ShaderTarget::Vertex => MONOCHROME_SPRITE_VERTEX_BYTES,
                    ShaderTarget::Fragment => MONOCHROME_SPRITE_FRAGMENT_BYTES,
                },
                ShaderModule::SubpixelSprite => match target {
                    ShaderTarget::Vertex => SUBPIXEL_SPRITE_VERTEX_BYTES,
                    ShaderTarget::Fragment => SUBPIXEL_SPRITE_FRAGMENT_BYTES,
                },
                ShaderModule::PolychromeSprite => match target {
                    ShaderTarget::Vertex => POLYCHROME_SPRITE_VERTEX_BYTES,
                    ShaderTarget::Fragment => POLYCHROME_SPRITE_FRAGMENT_BYTES,
                },
                ShaderModule::ImportedTexture => match target {
                    ShaderTarget::Vertex => IMPORTED_TEXTURE_VERTEX_BYTES,
                    ShaderTarget::Fragment => IMPORTED_TEXTURE_FRAGMENT_BYTES,
                },
                ShaderModule::EmojiRasterization => match target {
                    ShaderTarget::Vertex => EMOJI_RASTERIZATION_VERTEX_BYTES,
                    ShaderTarget::Fragment => EMOJI_RASTERIZATION_FRAGMENT_BYTES,
                },
            };
            Self { inner: bytes }
        }
    }

    #[cfg(debug_assertions)]
    pub(super) fn build_shader_blob(entry: ShaderModule, target: ShaderTarget) -> Result<ID3DBlob> {
        unsafe {
            use windows::Win32::Graphics::{
                Direct3D::ID3DInclude, Hlsl::D3D_COMPILE_STANDARD_FILE_INCLUDE,
            };

            let shader_name = if matches!(entry, ShaderModule::EmojiRasterization) {
                "color_text_raster.hlsl"
            } else {
                "shaders.hlsl"
            };

            let entry = format!(
                "{}_{}\0",
                entry.as_str(),
                match target {
                    ShaderTarget::Vertex => "vertex",
                    ShaderTarget::Fragment => "fragment",
                }
            );
            let target = match target {
                ShaderTarget::Vertex => "vs_4_1\0",
                ShaderTarget::Fragment => "ps_4_1\0",
            };

            let mut compile_blob = None;
            let mut error_blob = None;
            let shader_path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
                .join(&format!("src/{}", shader_name))
                .canonicalize()?;

            let entry_point = PCSTR::from_raw(entry.as_ptr());
            let target_cstr = PCSTR::from_raw(target.as_ptr());

            // really dirty trick because winapi bindings are unhappy otherwise
            let include_handler = &std::mem::transmute::<usize, ID3DInclude>(
                D3D_COMPILE_STANDARD_FILE_INCLUDE as usize,
            );

            let ret = D3DCompileFromFile(
                &HSTRING::from(shader_path.to_str().unwrap()),
                None,
                include_handler,
                entry_point,
                target_cstr,
                D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION,
                0,
                &mut compile_blob,
                Some(&mut error_blob),
            );
            if ret.is_err() {
                let Some(error_blob) = error_blob else {
                    return Err(anyhow::anyhow!("{ret:?}"));
                };

                let error_string =
                    std::ffi::CStr::from_ptr(error_blob.GetBufferPointer() as *const i8)
                        .to_string_lossy();
                log::error!("Shader compile error: {}", error_string);
                return Err(anyhow::anyhow!("Compile error: {}", error_string));
            }
            Ok(compile_blob.unwrap())
        }
    }

    #[cfg(not(debug_assertions))]
    include!(concat!(env!("OUT_DIR"), "/shaders_bytes.rs"));

    #[cfg(debug_assertions)]
    impl ShaderModule {
        pub fn as_str(self) -> &'static str {
            match self {
                ShaderModule::Quad => "quad",
                ShaderModule::Shadow => "shadow",
                ShaderModule::Underline => "underline",
                ShaderModule::PathRasterization => "path_rasterization",
                ShaderModule::PathSprite => "path_sprite",
                ShaderModule::MonochromeSprite => "monochrome_sprite",
                ShaderModule::SubpixelSprite => "subpixel_sprite",
                ShaderModule::PolychromeSprite => "polychrome_sprite",
                ShaderModule::ImportedTexture => "imported_texture",
                ShaderModule::EmojiRasterization => "emoji_rasterization",
            }
        }
    }
}

mod nvidia {
    use std::{
        ffi::CStr,
        os::raw::{c_char, c_int, c_uint},
    };

    use anyhow::Result;
    use windows::{Win32::System::LibraryLoader::GetProcAddress, core::s};

    use crate::with_dll_library;

    // https://github.com/NVIDIA/nvapi/blob/7cb76fce2f52de818b3da497af646af1ec16ce27/nvapi_lite_common.h#L180
    const NVAPI_SHORT_STRING_MAX: usize = 64;

    // https://github.com/NVIDIA/nvapi/blob/7cb76fce2f52de818b3da497af646af1ec16ce27/nvapi_lite_common.h#L235
    #[allow(non_camel_case_types)]
    type NvAPI_ShortString = [c_char; NVAPI_SHORT_STRING_MAX];

    // https://github.com/NVIDIA/nvapi/blob/7cb76fce2f52de818b3da497af646af1ec16ce27/nvapi_lite_common.h#L447
    #[allow(non_camel_case_types)]
    type NvAPI_SYS_GetDriverAndBranchVersion_t = unsafe extern "C" fn(
        driver_version: *mut c_uint,
        build_branch_string: *mut NvAPI_ShortString,
    ) -> c_int;

    pub(super) fn get_driver_version() -> Result<String> {
        #[cfg(target_pointer_width = "64")]
        let nvidia_dll_name = s!("nvapi64.dll");
        #[cfg(target_pointer_width = "32")]
        let nvidia_dll_name = s!("nvapi.dll");

        with_dll_library(nvidia_dll_name, |nvidia_dll| unsafe {
            let nvapi_query_addr = GetProcAddress(nvidia_dll, s!("nvapi_QueryInterface"))
                .ok_or_else(|| anyhow::anyhow!("Failed to get nvapi_QueryInterface address"))?;
            let nvapi_query: extern "C" fn(u32) -> *mut () = std::mem::transmute(nvapi_query_addr);

            // https://github.com/NVIDIA/nvapi/blob/7cb76fce2f52de818b3da497af646af1ec16ce27/nvapi_interface.h#L41
            let nvapi_get_driver_version_ptr = nvapi_query(0x2926aaad);
            if nvapi_get_driver_version_ptr.is_null() {
                anyhow::bail!("Failed to get NVIDIA driver version function pointer");
            }
            let nvapi_get_driver_version: NvAPI_SYS_GetDriverAndBranchVersion_t =
                std::mem::transmute(nvapi_get_driver_version_ptr);

            let mut driver_version: c_uint = 0;
            let mut build_branch_string: NvAPI_ShortString = [0; NVAPI_SHORT_STRING_MAX];
            let result = nvapi_get_driver_version(
                &mut driver_version as *mut c_uint,
                &mut build_branch_string as *mut NvAPI_ShortString,
            );

            if result != 0 {
                anyhow::bail!(
                    "Failed to get NVIDIA driver version, error code: {}",
                    result
                );
            }
            let major = driver_version / 100;
            let minor = driver_version % 100;
            let branch_string = CStr::from_ptr(build_branch_string.as_ptr());
            Ok(format!(
                "{}.{} {}",
                major,
                minor,
                branch_string.to_string_lossy()
            ))
        })
    }
}

mod amd {
    use std::os::raw::{c_char, c_int, c_void};

    use anyhow::Result;
    use windows::{Win32::System::LibraryLoader::GetProcAddress, core::s};

    use crate::with_dll_library;

    // https://github.com/GPUOpen-LibrariesAndSDKs/AGS_SDK/blob/5d8812d703d0335741b6f7ffc37838eeb8b967f7/ags_lib/inc/amd_ags.h#L145
    const AGS_CURRENT_VERSION: i32 = (6 << 22) | (3 << 12);

    // https://github.com/GPUOpen-LibrariesAndSDKs/AGS_SDK/blob/5d8812d703d0335741b6f7ffc37838eeb8b967f7/ags_lib/inc/amd_ags.h#L204
    // This is an opaque type, using struct to represent it properly for FFI
    #[repr(C)]
    struct AGSContext {
        _private: [u8; 0],
    }

    #[repr(C)]
    pub struct AGSGPUInfo {
        pub driver_version: *const c_char,
        pub radeon_software_version: *const c_char,
        pub num_devices: c_int,
        pub devices: *mut c_void,
    }

    // https://github.com/GPUOpen-LibrariesAndSDKs/AGS_SDK/blob/5d8812d703d0335741b6f7ffc37838eeb8b967f7/ags_lib/inc/amd_ags.h#L429
    #[allow(non_camel_case_types)]
    type agsInitialize_t = unsafe extern "C" fn(
        version: c_int,
        config: *const c_void,
        context: *mut *mut AGSContext,
        gpu_info: *mut AGSGPUInfo,
    ) -> c_int;

    // https://github.com/GPUOpen-LibrariesAndSDKs/AGS_SDK/blob/5d8812d703d0335741b6f7ffc37838eeb8b967f7/ags_lib/inc/amd_ags.h#L436
    #[allow(non_camel_case_types)]
    type agsDeInitialize_t = unsafe extern "C" fn(context: *mut AGSContext) -> c_int;

    pub(super) fn get_driver_version() -> Result<String> {
        #[cfg(target_pointer_width = "64")]
        let amd_dll_name = s!("amd_ags_x64.dll");
        #[cfg(target_pointer_width = "32")]
        let amd_dll_name = s!("amd_ags_x86.dll");

        with_dll_library(amd_dll_name, |amd_dll| unsafe {
            let ags_initialize_addr = GetProcAddress(amd_dll, s!("agsInitialize"))
                .ok_or_else(|| anyhow::anyhow!("Failed to get agsInitialize address"))?;
            let ags_deinitialize_addr = GetProcAddress(amd_dll, s!("agsDeInitialize"))
                .ok_or_else(|| anyhow::anyhow!("Failed to get agsDeInitialize address"))?;

            let ags_initialize: agsInitialize_t = std::mem::transmute(ags_initialize_addr);
            let ags_deinitialize: agsDeInitialize_t = std::mem::transmute(ags_deinitialize_addr);

            let mut context: *mut AGSContext = std::ptr::null_mut();
            let mut gpu_info: AGSGPUInfo = AGSGPUInfo {
                driver_version: std::ptr::null(),
                radeon_software_version: std::ptr::null(),
                num_devices: 0,
                devices: std::ptr::null_mut(),
            };

            let result = ags_initialize(
                AGS_CURRENT_VERSION,
                std::ptr::null(),
                &mut context,
                &mut gpu_info,
            );
            if result != 0 {
                anyhow::bail!("Failed to initialize AMD AGS, error code: {}", result);
            }

            // Vulkan actually returns this as the driver version
            let software_version = if !gpu_info.radeon_software_version.is_null() {
                std::ffi::CStr::from_ptr(gpu_info.radeon_software_version)
                    .to_string_lossy()
                    .into_owned()
            } else {
                "Unknown Radeon Software Version".to_string()
            };

            let driver_version = if !gpu_info.driver_version.is_null() {
                std::ffi::CStr::from_ptr(gpu_info.driver_version)
                    .to_string_lossy()
                    .into_owned()
            } else {
                "Unknown Radeon Driver Version".to_string()
            };

            ags_deinitialize(context);
            Ok(format!("{} ({})", software_version, driver_version))
        })
    }
}

mod dxgi {
    use windows::{
        Win32::Graphics::Dxgi::{IDXGIAdapter1, IDXGIDevice},
        core::Interface,
    };

    pub(super) fn get_driver_version(adapter: &IDXGIAdapter1) -> anyhow::Result<String> {
        let number = unsafe { adapter.CheckInterfaceSupport(&IDXGIDevice::IID as _) }?;
        Ok(format!(
            "{}.{}.{}.{}",
            number >> 48,
            (number >> 32) & 0xFFFF,
            (number >> 16) & 0xFFFF,
            number & 0xFFFF
        ))
    }
}

impl GpuRenderer for DirectXRenderer {
    type Device = ID3D11Device;

    /// The device, cloned out: the renderer is its only holder, so a producer reaches it through
    /// the renderer, but the handle is owned so it can outlive the call that lent it.
    fn device(&self) -> Option<ID3D11Device> {
        self.devices.as_ref().map(|devices| devices.device.clone())
    }
}

impl SceneRenderer for DirectXRenderer {
    fn draw(&mut self, scene: &Scene) -> bool {
        let background_appearance = self.background_appearance;
        self.draw(scene, background_appearance).log_err();
        true
    }

    fn sprite_atlas(&self) -> Arc<dyn PlatformAtlas> {
        DirectXRenderer::sprite_atlas(self)
    }

    /// The offscreen contract, in the shape the other two renderers have it: size the target,
    /// draw into it without presenting, and read it back only when a consumer on the CPU asks.
    /// Direct3D renders into its window's swap chain, so the size is the swap chain's and the
    /// window is what the renderer is built around — which is why there is no `new_headless` here.
    fn render_scene(&mut self, scene: &Scene, size: Size<DevicePixels>) -> anyhow::Result<()> {
        // A pending device-lost recovery (`skip_draws`) leaves the atlas holding tile references
        // from the previous device; drawing before the forced re-render rebuilds them panics in
        // `DirectXAtlasTextures::texture`.
        anyhow::ensure!(
            !self.skip_draws,
            "offscreen rendering is unavailable while recovering from a lost device"
        );
        self.resize(size)?;
        let background_appearance = self.background_appearance;
        self.render(scene, background_appearance)
    }

    fn read_pixels(&mut self) -> anyhow::Result<gpui_engine::PixelBuffer> {
        self.read_render_target()
    }
}

impl WinSceneRenderer for DirectXRenderer {
    fn set_background_appearance(&mut self, appearance: WindowBackgroundAppearance) {
        DirectXRenderer::set_background_appearance(self, appearance);
    }

    fn resize(&mut self, size: Size<DevicePixels>) -> anyhow::Result<()> {
        DirectXRenderer::resize(self, size)
    }

    fn mark_drawable(&mut self) {
        DirectXRenderer::mark_drawable(self);
    }
}

impl PlatformRenderer for DirectXRenderer {
    /// The window resizes through `WinSceneRenderer::resize`, which is where the DXGI failure it
    /// has to act on comes from; this exists for the generic path and can only log the same one.
    fn update_drawable_size(&mut self, size: Size<DevicePixels>) {
        DirectXRenderer::resize(self, size).log_err();
    }

    fn max_texture_size(&self) -> u32 {
        MAX_TEXTURE_SIZE
    }

    fn gpu_specs(&self) -> Option<GpuSpecs> {
        DirectXRenderer::gpu_specs(self).log_err()
    }

    /// Windows device loss is not a lost surface: the platform replaces the DirectX devices
    /// behind the window and hands them to the renderer in the target's backend extras.
    fn recover(&mut self, target: RendererTarget<'_>) -> anyhow::Result<()> {
        let devices = target
            .backend
            .and_then(|backend| backend.downcast_ref::<DirectXDevices>())
            .context("Direct3D recovery needs the replacement DirectXDevices in the target")?;
        DirectXRenderer::handle_device_lost(self, devices)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use gpui_engine::ImportedTextureHandle;
    use gpui_platform::{ContentMask, Corners, DevicePixels, Point, Size};
    use std::ffi::c_void;
    use windows::{
        Win32::{
            Foundation::{HWND, LPARAM, LRESULT, WPARAM},
            Graphics::Dxgi::Common::DXGI_FORMAT_R8G8B8A8_UNORM,
            System::LibraryLoader::GetModuleHandleW,
            UI::WindowsAndMessaging::{
                CreateWindowExW, DefWindowProcW, RegisterClassW, WINDOW_EX_STYLE, WNDCLASSW,
                WS_POPUP,
            },
        },
        core::{PCWSTR, w},
    };

    /// `DefWindowProcW` is a Rust-ABI wrapper in the `windows` crate, so a class that defaults
    /// every message still needs the `extern "system"` shape it asks for.
    unsafe extern "system" fn default_window_procedure(
        hwnd: HWND,
        msg: u32,
        wparam: WPARAM,
        lparam: LPARAM,
    ) -> LRESULT {
        unsafe { DefWindowProcW(hwnd, msg, wparam, lparam) }
    }

    /// A window the renderer can build a swap chain for, never shown: the readback path is what
    /// makes these tests independent of a visible window.
    fn hidden_window() -> Result<HWND> {
        const CLASS_NAME: PCWSTR = w!("Zed::DirectXRendererTest");
        unsafe {
            let module = GetModuleHandleW(None)?;
            let window_class = WNDCLASSW {
                lpfnWndProc: Some(default_window_procedure),
                lpszClassName: CLASS_NAME,
                hInstance: module.into(),
                ..Default::default()
            };
            // Once per process; a repeat registration fails harmlessly.
            RegisterClassW(&window_class);
            CreateWindowExW(
                WINDOW_EX_STYLE(0),
                CLASS_NAME,
                CLASS_NAME,
                WS_POPUP,
                0,
                0,
                8,
                8,
                None,
                None,
                Some(module.into()),
                None,
            )
            .context("creating the hidden test window")
        }
    }

    /// A renderer for `viewport` with no visible window, or `None` where this machine has no
    /// Direct3D 11 device at all. A bare Windows runner has WARP, so the guard is a formality
    /// rather than the expected path, and it logs why it skipped.
    fn test_renderer(viewport: Size<DevicePixels>) -> Option<DirectXRenderer> {
        let devices = match DirectXDevices::new(&gpui_platform::GpuPreference::Auto) {
            Ok(devices) => devices,
            Err(error) => {
                log::warn!("no Direct3D 11 device to render offscreen with; skipping: {error:#}");
                return None;
            }
        };
        let hwnd = match hidden_window() {
            Ok(hwnd) => hwnd,
            Err(error) => {
                log::warn!("could not create a hidden window; skipping: {error:#}");
                return None;
            }
        };
        let mut renderer = match DirectXRenderer::new(hwnd, &devices, true) {
            Ok(renderer) => renderer,
            Err(error) => {
                log::warn!("could not build a Direct3D renderer; skipping: {error:#}");
                return None;
            }
        };
        if let Err(error) = renderer.resize(viewport) {
            log::warn!("could not size the Direct3D renderer; skipping: {error:#}");
            return None;
        }
        Some(renderer)
    }

    /// A texture on `device` holding `bgra` in every pixel, which is what a producer that wrote
    /// one would leave behind. `format` is a parameter so a test can hand the boundary something
    /// it has to refuse.
    fn imported_texture(
        device: &ID3D11Device,
        size: u32,
        format: DXGI_FORMAT,
        bgra: [u8; 4],
    ) -> Result<ID3D11Texture2D> {
        let pixels: Vec<u8> = bgra
            .iter()
            .copied()
            .cycle()
            .take((size * size * 4) as usize)
            .collect();
        let desc = D3D11_TEXTURE2D_DESC {
            Width: size,
            Height: size,
            MipLevels: 1,
            ArraySize: 1,
            Format: format,
            SampleDesc: DXGI_SAMPLE_DESC {
                Count: 1,
                Quality: 0,
            },
            Usage: D3D11_USAGE_DEFAULT,
            BindFlags: D3D11_BIND_SHADER_RESOURCE.0 as u32,
            CPUAccessFlags: 0,
            MiscFlags: 0,
        };
        let initial_data = D3D11_SUBRESOURCE_DATA {
            pSysMem: pixels.as_ptr() as *const c_void,
            SysMemPitch: size * 4,
            SysMemSlicePitch: 0,
        };
        let mut texture = None;
        unsafe { device.CreateTexture2D(&desc, Some(&initial_data), Some(&mut texture))? };
        texture.context("CreateTexture2D returned no texture")
    }

    /// A scene whose only primitive is an imported texture covering the whole target.
    fn imported_texture_scene(
        handle: ImportedTextureHandle,
        viewport: Size<DevicePixels>,
    ) -> Scene {
        let bounds = Bounds {
            origin: Point {
                x: 0.0.into(),
                y: 0.0.into(),
            },
            size: Size {
                width: (viewport.width.0 as f32).into(),
                height: (viewport.height.0 as f32).into(),
            },
        };
        let mut scene = Scene::default();
        scene.custom.push(CustomRenderPrimitive::Texture {
            order: 0,
            handle,
            bounds,
            content_mask: ContentMask { bounds },
            radii: Corners::default(),
            opacity: 1.0,
            flip_v: false,
        });
        scene
    }

    /// A scene whose only primitive is a surface covering the whole target.
    fn surface_scene(source: SurfaceSource, viewport: Size<DevicePixels>) -> Scene {
        let bounds = Bounds {
            origin: Point {
                x: 0.0.into(),
                y: 0.0.into(),
            },
            size: Size {
                width: (viewport.width.0 as f32).into(),
                height: (viewport.height.0 as f32).into(),
            },
        };
        let mut scene = Scene::default();
        scene.surfaces.push(PaintSurface {
            order: 0,
            bounds,
            content_mask: ContentMask { bounds },
            source,
        });
        scene
    }

    /// The colour row. A producer's bytes have to come back unchanged, and on this renderer they
    /// do so exactly rather than approximately: the sampler reads the texture's own non-sRGB view
    /// and the fragment writes that straight into the non-sRGB target, so there is no transfer
    /// function to cancel. A decode here would be the ≈2.2 error the wgpu backend's re-encode exists
    /// to cancel — and the only encoder this shader file has is `linear_to_srgb`'s approximation.
    #[test]
    fn an_imported_texture_round_trips_its_bytes() -> Result<()> {
        let viewport = Size {
            width: DevicePixels(8),
            height: DevicePixels(8),
        };
        let Some(mut renderer) = test_renderer(viewport) else {
            return Ok(());
        };

        // Distinct per channel, and far from either end, so a transfer function applied once in
        // the wrong direction cannot round back to the same byte.
        let fixture = [200u8, 100, 50, 255];
        // The producer's half: the device comes through `GpuRenderer::device`, the route an
        // application has, and the texture is made on it rather than on the renderer's own field.
        let device = GpuRenderer::device(&renderer)
            .context("the renderer lends its device through the seam")?;
        let texture = imported_texture(
            &device,
            1,
            DXGI_FORMAT_B8G8R8A8_UNORM,
            [fixture[2], fixture[1], fixture[0], fixture[3]],
        )?;
        let scene = imported_texture_scene(texture.to_imported_handle()?, viewport);

        let pixels = renderer.render_scene_to_image(&scene, viewport)?;
        assert_eq!((pixels.width(), pixels.height()), (8, 8));
        for (index, pixel) in pixels.data().chunks_exact(4).enumerate() {
            assert_eq!(pixel, fixture, "pixel {index} did not round trip");
        }
        Ok(())
    }

    /// The surface row — the byte-for-byte round trip through `draw_surfaces` rather than
    /// `draw_custom`. This one carries a `DirectXSource::View`, the view the producer made, so the
    /// producer's half is the same texture plus the view `create_imported_texture_view` builds; the
    /// fragment samples it straight through, exactly as it samples an imported texture's.
    #[test]
    fn a_surface_round_trips_its_bytes() -> Result<()> {
        let viewport = Size {
            width: DevicePixels(8),
            height: DevicePixels(8),
        };
        let Some(mut renderer) = test_renderer(viewport) else {
            return Ok(());
        };

        // Distinct per channel, and far from either end, so a transfer function applied once in
        // the wrong direction cannot round back to the same byte.
        let fixture = [200u8, 100, 50, 255];
        let device = GpuRenderer::device(&renderer)
            .context("the renderer lends its device through the seam")?;
        let texture = imported_texture(
            &device,
            1,
            DXGI_FORMAT_B8G8R8A8_UNORM,
            [fixture[2], fixture[1], fixture[0], fixture[3]],
        )?;
        let view = create_imported_texture_view(&device, &texture)?;
        let scene = surface_scene(SurfaceSource::DirectX(DirectXSource::View(view)), viewport);

        let pixels = renderer.render_scene_to_image(&scene, viewport)?;
        assert_eq!((pixels.width(), pixels.height()), (8, 8));
        for (index, pixel) in pixels.data().chunks_exact(4).enumerate() {
            assert_eq!(pixel, fixture, "pixel {index} did not round trip");
        }
        Ok(())
    }

    /// The `Texture` variant of the surface row: the producer hands the texture rather than a view, and
    /// the renderer makes the view itself, with the same `create_imported_texture_view` rules and
    /// the non-sRGB format that leaves the fragment nothing to cancel. Two frames exercise both
    /// sides of the view cache — the miss that builds the view and the hit that reuses it — so a
    /// descriptor allocated per frame would show up here as a second, needless
    /// `CreateShaderResourceView` rather than as a wrong pixel.
    #[test]
    fn a_surface_texture_round_trips_its_bytes() -> Result<()> {
        let viewport = Size {
            width: DevicePixels(8),
            height: DevicePixels(8),
        };
        let Some(mut renderer) = test_renderer(viewport) else {
            return Ok(());
        };

        // Distinct per channel, and far from either end, so a transfer function applied once in
        // the wrong direction cannot round back to the same byte.
        let fixture = [200u8, 100, 50, 255];
        let device = GpuRenderer::device(&renderer)
            .context("the renderer lends its device through the seam")?;
        let texture = imported_texture(
            &device,
            1,
            DXGI_FORMAT_B8G8R8A8_UNORM,
            [fixture[2], fixture[1], fixture[0], fixture[3]],
        )?;
        let scene = surface_scene(
            SurfaceSource::DirectX(DirectXSource::Texture(texture)),
            viewport,
        );

        for frame in 0..2 {
            let pixels = renderer.render_scene_to_image(&scene, viewport)?;
            assert_eq!((pixels.width(), pixels.height()), (8, 8));
            for (index, pixel) in pixels.data().chunks_exact(4).enumerate() {
                assert_eq!(
                    pixel, fixture,
                    "pixel {index} did not round trip on frame {frame}"
                );
            }
        }
        Ok(())
    }

    /// The `Texture` variant's boundary. The view the renderer makes for a producer's texture is
    /// fixed at the target's own `B8G8R8A8_UNORM` channel order, so a texture in the other order
    /// is refused by `create_imported_texture_view` — skip-with-a-reason, the soft fault the `View`
    /// variant's `surface_view_is_sampleable` makes — rather than viewed and composited with red and
    /// blue exchanged. A composited surface would paint this texture's bytes over the whole
    /// target; a skipped one leaves the frame's clear (white, the opaque background) untouched.
    #[test]
    fn a_surface_texture_in_the_wrong_format_is_skipped() -> Result<()> {
        let viewport = Size {
            width: DevicePixels(8),
            height: DevicePixels(8),
        };
        let Some(mut renderer) = test_renderer(viewport) else {
            return Ok(());
        };

        let device = GpuRenderer::device(&renderer)
            .context("the renderer lends its device through the seam")?;
        // RGBA rather than BGRA: same-device and otherwise sampleable, so only the channel order
        // can be what refuses it. The bytes are distinctive so a composite would be unmistakable.
        let texture = imported_texture(&device, 1, DXGI_FORMAT_R8G8B8A8_UNORM, [10, 20, 30, 255])?;
        let scene = surface_scene(
            SurfaceSource::DirectX(DirectXSource::Texture(texture)),
            viewport,
        );

        // Refused, but softly: the frame still renders and reads back rather than faulting.
        let pixels = renderer.render_scene_to_image(&scene, viewport)?;
        assert_eq!((pixels.width(), pixels.height()), (8, 8));
        for (index, pixel) in pixels.data().chunks_exact(4).enumerate() {
            assert_eq!(
                pixel,
                [255, 255, 255, 255],
                "pixel {index} was composited; the wrong-format texture was not skipped"
            );
        }
        Ok(())
    }

    /// The `View` variant across successive frames: a producer's view is sampled as it is every frame —
    /// unlike the `Texture` variant it is never cached — and the immediate unbind the draw does leaves
    /// the next frame free to bind and sample it again.
    #[test]
    fn a_surface_view_round_trips_its_bytes() -> Result<()> {
        let viewport = Size {
            width: DevicePixels(8),
            height: DevicePixels(8),
        };
        let Some(mut renderer) = test_renderer(viewport) else {
            return Ok(());
        };

        // Distinct per channel, and far from either end, so a transfer function applied once in
        // the wrong direction cannot round back to the same byte.
        let fixture = [200u8, 100, 50, 255];
        let device = GpuRenderer::device(&renderer)
            .context("the renderer lends its device through the seam")?;
        let texture = imported_texture(
            &device,
            1,
            DXGI_FORMAT_B8G8R8A8_UNORM,
            [fixture[2], fixture[1], fixture[0], fixture[3]],
        )?;
        let view = create_imported_texture_view(&device, &texture)?;
        let scene = surface_scene(SurfaceSource::DirectX(DirectXSource::View(view)), viewport);

        for frame in 0..2 {
            let pixels = renderer.render_scene_to_image(&scene, viewport)?;
            assert_eq!((pixels.width(), pixels.height()), (8, 8));
            for (index, pixel) in pixels.data().chunks_exact(4).enumerate() {
                assert_eq!(
                    pixel, fixture,
                    "pixel {index} did not round trip on frame {frame}"
                );
            }
        }
        Ok(())
    }

    /// The device-identity row, and the one place this renderer is stronger than `wgpu`: the
    /// same-device rule is what makes the token rather than a handle enough, and Direct3D enforces
    /// it by name — `CreateShaderResourceView` refuses a resource another device made, where wgpu's
    /// refusal is a panic inside its own storage lookup.
    #[test]
    fn an_imported_texture_from_another_device_is_rejected() -> Result<()> {
        let viewport = Size {
            width: DevicePixels(8),
            height: DevicePixels(8),
        };
        let Some(mut renderer) = test_renderer(viewport) else {
            return Ok(());
        };

        let other_devices = DirectXDevices::new(&gpui_platform::GpuPreference::Auto)?;
        let texture = imported_texture(
            &other_devices.device,
            1,
            DXGI_FORMAT_B8G8R8A8_UNORM,
            [50, 100, 200, 255],
        )?;
        let scene = imported_texture_scene(texture.to_imported_handle()?, viewport);

        assert!(
            renderer.render_scene_to_image(&scene, viewport).is_err(),
            "a texture from another device must not composite"
        );
        Ok(())
    }

    /// The boundary row. The fragment writes the sample through, so a texture in another channel
    /// order would composite with red and blue exchanged rather than failing; the extension is
    /// where that is caught, with a message that names the producer's mistake.
    #[test]
    fn an_imported_texture_in_the_wrong_format_is_refused() -> Result<()> {
        let devices = match DirectXDevices::new(&gpui_platform::GpuPreference::Auto) {
            Ok(devices) => devices,
            Err(error) => {
                log::warn!("no Direct3D 11 device to build a texture on; skipping: {error:#}");
                return Ok(());
            }
        };
        let texture = imported_texture(
            &devices.device,
            1,
            DXGI_FORMAT_R8G8B8A8_UNORM,
            [50, 100, 200, 255],
        )?;

        assert!(
            texture.to_imported_handle().is_err(),
            "an RGBA texture would composite with red and blue exchanged"
        );
        Ok(())
    }
}