upgrade winapi bindings to 0.54

Author: modelflat

Cargo.lock

@@ -10,8 +10,7 @@ name = "zbl"
 once_cell = "1"
 
 [dependencies.windows]
-# TODO bumping the version brings on weird API which i'm not sure how to work with
-version = "0.43"
+version = "0.54"
 features = [
     "Foundation",
     "Graphics_Capture",

zbl/Cargo.toml

@@ -81,7 +81,7 @@ extern "system" fn enum_windows_cb(window: HWND, state: LPARAM) -> BOOL {
 fn enumerate_capturable_windows() -> Vec<Window> {
     let state = Box::into_raw(Box::default());
     *unsafe {
-        EnumWindows(Some(enum_windows_cb), LPARAM(state as isize));
+        EnumWindows(Some(enum_windows_cb), LPARAM(state as isize)).expect("EnumWindows");
         Box::from_raw(state)
     }
 }
@@ -213,9 +213,9 @@ impl Capturable for Window {
         let mut client_rect = RECT::default();
         let mut top_left = POINT::default();
         unsafe {
-            GetWindowRect(self.handle, &mut window_rect as *mut _);
+            GetWindowRect(self.handle, &mut window_rect as *mut _).expect("GetWindowRect");
             ClientToScreen(self.handle, &mut top_left as *mut _);
-            GetClientRect(self.handle, &mut client_rect as *mut _);
+            GetClientRect(self.handle, &mut client_rect as *mut _).expect("GetWindowRect");
         }
 
         let mut client_box = D3D11_BOX::default();

zbl/src/capture/window.rs

@@ -57,9 +57,9 @@ impl D3D {
     pub fn new() -> Result<Self> {
         let device = create_d3d_device()?;
         let context = unsafe {
-            let mut d3d_context = None;
-            device.GetImmediateContext(&mut d3d_context);
-            d3d_context.expect("failed to create d3d_context")
+            device
+                .GetImmediateContext()
+                .expect("D3D11 immediate context")
         };
         let direct3d_device = create_direct3d_device(&device)?;
         Ok(Self {

zbl/src/d3d.rs

@@ -2,9 +2,9 @@ use windows::{
     core::{Interface, Result},
     Win32::Graphics::{
         Direct3D11::{
-            ID3D11Device, ID3D11DeviceContext, ID3D11Resource, ID3D11Texture2D, D3D11_BIND_FLAG,
-            D3D11_CPU_ACCESS_READ, D3D11_MAPPED_SUBRESOURCE, D3D11_MAP_READ,
-            D3D11_RESOURCE_MISC_FLAG, D3D11_TEXTURE2D_DESC, D3D11_USAGE_STAGING,
+            ID3D11Device, ID3D11DeviceContext, ID3D11Resource, ID3D11Texture2D,
+            D3D11_CPU_ACCESS_READ, D3D11_MAPPED_SUBRESOURCE, D3D11_MAP_READ, D3D11_TEXTURE2D_DESC,
+            D3D11_USAGE_STAGING,
         },
         Dxgi::Common::{DXGI_FORMAT, DXGI_SAMPLE_DESC},
     },
@@ -33,15 +33,21 @@ impl StagingTexture {
                 Count: 1,
                 Quality: 0,
             },
-            BindFlags: D3D11_BIND_FLAG(0),
-            MiscFlags: D3D11_RESOURCE_MISC_FLAG(0),
+            BindFlags: 0,
+            MiscFlags: 0,
             Usage: D3D11_USAGE_STAGING,
-            CPUAccessFlags: D3D11_CPU_ACCESS_READ,
+            CPUAccessFlags: D3D11_CPU_ACCESS_READ.0 as u32,
         };
 
-        let texture = unsafe { device.CreateTexture2D(&desc, None)? };
+        let mut texture = None;
+        unsafe {
+            device.CreateTexture2D(&desc, None, Some(&mut texture))?;
+        }
 
-        Ok(Self { texture, desc })
+        Ok(Self {
+            texture: texture.expect("CreateTexture2D"),
+            desc,
+        })
     }
 
     pub fn as_resource(&self) -> Result<ID3D11Resource> {
@@ -50,8 +56,16 @@ impl StagingTexture {
 
     pub fn as_mapped(&self, context: &ID3D11DeviceContext) -> Result<D3D11_MAPPED_SUBRESOURCE> {
         let staging_texture_ptr: ID3D11Resource = self.texture.cast()?;
-        let mapped_texture =
-            unsafe { context.Map(Some(&staging_texture_ptr), 0, D3D11_MAP_READ, 0)? };
+        let mut mapped_texture = D3D11_MAPPED_SUBRESOURCE::default();
+        unsafe {
+            context.Map(
+                Some(&staging_texture_ptr),
+                0,
+                D3D11_MAP_READ,
+                0,
+                Some(&mut mapped_texture),
+            )?;
+        }
         // we can instantly unmap because the texture is staging, and will be still accessible by CPU
         // TODO there should be a way to do this by queueing a fence (we only need to wait copies) or something like that,
         // which would probably be more correct solution rather than map-unmap