Method new_from_compatible_surface

crates/wgpu_context/src/lib.rs:31–73

Creates a `DeviceHandle` with `Device` that's compatible with the specified `Surface`

(
        instance: Instance,
        compatible_surface: Option<&Surface<'_>>,
        extra_features: Option<Features>,
        override_limits: Option<Limits>,
    )

}

impl DeviceHandle {
    /// Creates a `DeviceHandle` with `Device` that's compatible with the specified `Surface`
    pub async fn new_from_compatible_surface(
        instance: Instance,
        compatible_surface: Option<&Surface<'_>>,
        extra_features: Option<Features>,
        override_limits: Option<Limits>,
    ) -> Result<Self, WgpuContextError> {
        let adapter =
            wgpu::util::initialize_adapter_from_env_or_default(&instance, compatible_surface)
                .await?;

        // Determine features to request
        // The user may request additional features
        let requested_features = extra_features.unwrap_or(Features::empty());
        let available_features = adapter.features();
        let required_features = requested_features & available_features;

        // Determine limits to request
        // The user may override the limits
        let required_limits = override_limits.clone().unwrap_or_else(|| Limits {
            // Fix iOS simulator
            max_inter_stage_shader_variables: 15,
            ..Limits::default()
        });

        // Create the device and the queue
        let descripter = wgpu::DeviceDescriptor {
            label: None,
            required_features,
            required_limits,
            memory_hints: MemoryHints::MemoryUsage,
            trace: wgpu::Trace::default(),
            experimental_features: wgpu::ExperimentalFeatures::default(),
        };
        let (device, queue) = adapter.request_device(&descripter).await?;

        // Create the device handle and store in the pool
        Ok(DeviceHandle {
            instance,
            adapter,
            device,
            queue,
        })
    }