covk_sys 0.1.2-1.4.345

Low-level unsafe vulkan bindings for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

# covk


[![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE-MIT)
[![MSRV](https://img.shields.io/badge/rustc-1.93.0+-ab6000.svg)](https://blog.rust-lang.org/2023/04/20/Rust-1.93.0.html)

Unsafe Vulkan bindings for Rust

- `no_std` support
- Vulkan `1.0` `1.1` `1.2` `1.3` `1.4`

- `covk_sys`

  [![Crates.io Version](https://img.shields.io/crates/v/covk_sys.svg)](https://crates.io/crates/covk_sys)
  [![Documentation](https://docs.rs/covk_sys/badge.svg)](https://docs.rs/covk_sys)

  Original bindings, pure vulkan style.

- `covk`

  [![Crates.io Version](https://img.shields.io/crates/v/covk.svg)](https://crates.io/crates/covk)
  [![Documentation](https://docs.rs/covk/badge.svg)](https://docs.rs/covk)

  - Rust style wrapping
  - Prelude
    ```rust
    use covk::prelude::*;
    ```
  - The vulkan loader
    ```rust
    let vk = Vulkan::new()?;
    ```
  - Return the `Result`
    ```rust
    // function signature
    pub unsafe fn create_instance(
        &self, create_info: &vk::InstanceCreateInfo,
        // allocation_callbacks have been hidden, if you need should use covk_sys or other crate
    ) -> Result<vk::Instance>;

    let inst: vk::Instance = vk.create_instance(&info)?;
    ```
  - NonNull handles
    ```rust
    // vk::Instance
    pub struct Instance(pub NonNull<void>);
    ```
  - RAII handles
    ```rust
    // RAII handles are opaque reference counting heap object
    let inst: hnd::Instance = vk.create_instance(&info)?.hnd(&vk);
    // actual hnd::Instance<vk::core>

    // add ref
    let _inst = inst.clone();

    // get the raw handle
    let raw: vk::Instance = inst.raw();
    ```
  - Query the ext
    ```rust
    let sf: hnd::Instance<vk::khr::surface> = inst.ext::<vk::khr::surface>();
    ```
  - `Vec` on enumerate like api
    ```rust
    // function signature
    // you still can check the count
    pub unsafe fn enumerate_instance_layer_properties(
        &self,
        properties: Option<&mut Vec<vk::LayerProperties>>,
    ) -> Result<(u32, vk::Result)>;

    // will be append to vec, not overwritten
    let mut layers = vec![];
    vk.enumerate_instance_layer_properties(Some(&mut layers))?;
    ```
  - Struct builder
    ```rust
    // vk::new include all required fileds
    let app_info: vk::ApplicationInfo = vk::new::ApplicationInfo {
       application_version: 0,
       engine_version: 0,
       api_version: vk::API_VERSION_1_4,
    }.new();
    let mut info = vk::new::InstanceCreateInfo {
        p_enabled_layer_names: &enable_layers,
        p_enabled_extension_names: &enabled_exts,
    }
    // .new or .builder method
    .application_info(&app_info);


    let mut info = vk::DeviceCreateInfo::default()
        .queue_create_infos(&queue_infos)
        .p_enabled_extension_names(&enabled_exts)
        .enabled_features(&mut features.features);

    // push next &mut Self -> &mut Self, or with_next Self -> Self
    info.push_next(&mut features_1_4);
    
    let device: hnd::Device = inst.create_device(adapter, &info)?.hnd(&inst.hnd);
    let sc: hnd::Device<vk::khr::swapchain> = device.ext::<vk::khr::swapchain>();
    let queue: vk::Queue = device.get_queue(main_queue_family, 0);
    ```
  - Object style traits
    ```rust
    pub trait CoreCommandBuffer {
        // required methods
        fn raw(&self) -> vk::CommandBuffer;
        fn commands(&self) -> &Device;
        ...
        unsafe fn set_viewport(
            &self,
            first_viewport: uint32_t,
            viewports: &[Viewport],
        ) -> () {
            unsafe {
                self.commands().cmd_set_viewport(
                    self.raw(),
                    first_viewport,
                    viewports,
                )
            }
        }
        ...
    }

    // cmd: any impled CoreCommandBuffer
    cmd.set_viewport(
        0,
        &[vk::Viewport {
            x: 0.0,
            y: height as f32,
            width: width as f32,
            height: -(height as f32),
            min_depth: 0.0,
            max_depth: 1.0,
        }],
    );
    ```
    
### Examples


- [covk/examples/cube.rs](./covk/examples/cube.rs)
- [covk_sys/examples/cube.rs](./covk_sys/examples/sys_cube.rs)

![Cube](./assets/Cube.png)

### Gen


- Require rust
- Require pwsh
- Require .NET 10
- Require `cargo-edit`

    ```shell
    cargo install cargo-edit
    ```


```pwsh
./gen.ps1
```