size: winit::dpi::PhysicalSize<u32>,

    size: PhysicalSize<u32>,
    /// Used for valid resizes, that simply were dropped before we made a screen
    queued_size: Option<PhysicalSize<u32>>,

                    required_limits: if cfg!(target_arch = "wasm32") {

                    required_limits: {let default_limits = if cfg!(target_arch = "wasm32") {

                    },

                    };
                    // This would be to allow adjusting limits downwards for max compat, but
                    // Firefox has 0s everywhere meh
                    default_limits
                },

        // resize to our queued size, now that we definitely have a surface and adapter state
        if let Some(queued_size) = self.queued_size.take() {
            self.resize(queued_size);
        }

                    required_features: wgpu::Features::all_webgpu_mask(),

                    required_features: wgpu::Features::empty(), //wgpu::Features::all_webgpu_mask(),

            queued_size: None,

            } else {
                self.queued_size = Some(new_size);

        let inner_size = self.window.inner_size();

            size_in_pixels: inner_size.into(),

            size_in_pixels: self.size.into(),

        let logical_width = inner_size.width as f64 / scale_factor;
        let logical_height = inner_size.height as f64 / scale_factor;

            width: logical_width as u32,
            height: logical_height as u32,

            width: self.size.width / scale_factor as u32,
            height: self.size.height / scale_factor as u32,