Improve GPU memory management and error handling (Rust-SDL2#87)

This change wraps the inner points for the GPU Shader,
Texture, GraphicsPipeline, Buffer, and TransferBuffer resources
in Arcs so that manual memory management isn't necessary.
These resources require the device to be released, so they
also track a weak pointer back to the device, and their release
is conditional on the device still existing.

The device itself now has its raw pointer wrapped in an Arc.
Clone implementations are added to all of these to make working with
them in a larger project easier.

The release functions were all removed, and the resources can simply be
more idiomatically dropped now.

Additionally, the `wait_and_acquire_swapchain_texture` and
`acquire_swapchain_texture` functions were moved from the Device into
the CommandBuffer. This made more sense organizationally since neither
functions use the device at all, and their first argument is the command
buffer pointer.

Finally, missing error handling was added for many unsafe SDL function calls.

Author: jdisanti

examples/gpu-clear.rs

@@ -17,7 +17,7 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
     // by default, and we specify that our shaders will be SPIR-V ones (even through we
     // aren't using any shaders)
     // We'll also turn on debug mode to true, so we get debug stuff
-    let gpu = sdl3::gpu::Device::new(sdl3::gpu::ShaderFormat::SpirV, true).with_window(&window)?;
+    let gpu = sdl3::gpu::Device::new(sdl3::gpu::ShaderFormat::SpirV, true)?.with_window(&window)?;
 
     let mut event_pump = sdl_context.event_pump()?;
     println!(
@@ -40,12 +40,11 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         //
         // This is because a swapchain needs to be "allocated", and it can quickly run out
         // if we don't properly time the rendering process.
-        let mut command_buffer = gpu.acquire_command_buffer();
-        if let Ok(swapchain) = gpu.wait_and_acquire_swapchain_texture(&window, &mut command_buffer)
-        {
+        let mut command_buffer = gpu.acquire_command_buffer()?;
+        if let Ok(swapchain) = command_buffer.wait_and_acquire_swapchain_texture(&window) {
             let color_targets = [
                 sdl3::gpu::ColorTargetInfo::default()
-                    .with_texture(swapchain) // Use swapchain texture
+                    .with_texture(&swapchain) // Use swapchain texture
                     .with_load_op(sdl3::gpu::LoadOp::Clear) // Clear when load
                     .with_store_op(sdl3::gpu::StoreOp::Store) // Store back
                     .with_clear_color(sdl3::pixels::Color::RGB(5, 3, 255)), //blue with small RG bias

examples/gpu-cube.rs

@@ -11,6 +11,7 @@ use sdl3::{
     },
     keyboard::Keycode,
     pixels::Color,
+    Error,
 };
 
 extern crate sdl3;
@@ -87,10 +88,10 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         .build()
         .map_err(|e| e.to_string())?;
 
-    let gpu = sdl3::gpu::Device::new(
+    let gpu = Device::new(
         ShaderFormat::SpirV | ShaderFormat::Dxil | ShaderFormat::Dxbc | ShaderFormat::MetalLib,
         true,
-    )
+    )?
     .with_window(&window)?;
 
     // Our shaders, require to be precompiled by a SPIR-V compiler beforehand
@@ -127,7 +128,7 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
             VertexInputState::new()
                 .with_vertex_buffer_descriptions(&[VertexBufferDescription::new()
                     .with_slot(0)
-                    .with_pitch((size_of::<f32>() * 3) as u32) // 3 floats per vertex
+                    .with_pitch(size_of::<VertexPosition>() as u32)
                     .with_input_rate(VertexInputRate::Vertex)
                     .with_instance_step_rate(0)])
                 .with_vertex_attributes(&[VertexAttribute::new()
@@ -160,8 +161,8 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         .build()?;
 
     // The pipeline now holds copies of our shaders, so we can release them
-    vert_shader.release(&gpu);
-    frag_shader.release(&gpu);
+    drop(vert_shader);
+    drop(frag_shader);
 
     // Next, we create a transfer buffer that is large enough to hold either
     // our vertices or indices since we will be transferring both with it.
@@ -171,10 +172,10 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         .create_transfer_buffer()
         .with_size(vertices_len_bytes.max(indices_len_bytes) as u32)
         .with_usage(TransferBufferUsage::Upload)
-        .build();
+        .build()?;
 
     // We need to start a copy pass in order to transfer data to the GPU
-    let copy_commands = gpu.acquire_command_buffer();
+    let copy_commands = gpu.acquire_command_buffer()?;
     let copy_pass = gpu.begin_copy_pass(&copy_commands)?;
 
     // Create GPU buffers to hold our vertices and indices and transfer data to them
@@ -184,17 +185,17 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         &copy_pass,
         BufferUsageFlags::Vertex,
         &CUBE_VERTICES,
-    );
+    )?;
     let index_buffer = create_buffer_with_data(
         &gpu,
         &transfer_buffer,
         &copy_pass,
         BufferUsageFlags::Index,
         &CUBE_INDICES,
-    );
+    )?;
 
     // We're done with the transfer buffer now, so release it.
-    transfer_buffer.release(&gpu);
+    drop(transfer_buffer);
 
     // Now complete and submit the copy pass commands to actually do the transfer work
     gpu.end_copy_pass(copy_pass);
@@ -211,7 +212,7 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
             .with_sample_count(SampleCount::NoMultiSampling)
             .with_format(TextureFormat::D16Unorm)
             .with_usage(TextureUsage::Sampler | TextureUsage::DepthStencilTarget),
-    );
+    )?;
 
     let mut rotation = 45.0f32;
     let mut event_pump = sdl_context.event_pump()?;
@@ -232,12 +233,11 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         //
         // This is because a swapchain needs to be "allocated", and it can quickly run out
         // if we don't properly time the rendering process.
-        let mut command_buffer = gpu.acquire_command_buffer();
-        if let Ok(swapchain) = gpu.wait_and_acquire_swapchain_texture(&window, &mut command_buffer)
-        {
+        let mut command_buffer = gpu.acquire_command_buffer()?;
+        if let Ok(swapchain) = command_buffer.wait_and_acquire_swapchain_texture(&window) {
             // Again, like in gpu-clear.rs, we'd want to define basic operations for our cube
             let color_targets = [ColorTargetInfo::default()
-                .with_texture(swapchain)
+                .with_texture(&swapchain)
                 .with_load_op(LoadOp::Clear)
                 .with_store_op(StoreOp::Store)
                 .with_clear_color(Color::RGB(128, 128, 128))];
@@ -296,7 +296,7 @@ fn create_buffer_with_data<T: Copy>(
     copy_pass: &CopyPass,
     usage: BufferUsageFlags,
     data: &[T],
-) -> Buffer {
+) -> Result<Buffer, Error> {
     // Figure out the length of the data in bytes
     let len_bytes = data.len() * std::mem::size_of::<T>();
 
@@ -305,7 +305,7 @@ fn create_buffer_with_data<T: Copy>(
         .create_buffer()
         .with_size(len_bytes as u32)
         .with_usage(usage)
-        .build();
+        .build()?;
 
     // Map the transfer buffer's memory into a place we can copy into, and copy the data
     //
@@ -335,5 +335,5 @@ fn create_buffer_with_data<T: Copy>(
         true,
     );
 
-    buffer
+    Ok(buffer)
 }

examples/gpu-triangle.rs

@@ -1,10 +1,7 @@
 extern crate sdl3;
 
 use sdl3::keyboard::Keycode;
-use sdl3::pixels::Color;
 use sdl3::{event::Event, gpu::GraphicsPipelineTargetInfo};
-use sdl3_sys::render;
-use std::time::Duration;
 
 pub fn main() -> Result<(), Box<dyn std::error::Error>> {
     let sdl_context = sdl3::init()?;
@@ -26,7 +23,7 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
             | sdl3::gpu::ShaderFormat::Dxbc
             | sdl3::gpu::ShaderFormat::MetalLib,
         true,
-    )
+    )?
     .with_window(&window)?;
 
     let fs_source = include_bytes!("shaders/triangle.frag.spv");
@@ -73,8 +70,9 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         )
         .build()?;
 
-    vs_shader.release(&gpu);
-    fs_shader.release(&gpu);
+    // The pipeline now holds copies of our shaders, so we can release them
+    drop(vs_shader);
+    drop(fs_shader);
 
     let mut event_pump = sdl_context.event_pump()?;
     println!(
@@ -97,13 +95,12 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         //
         // This is because a swapchain needs to be "allocated", and it can quickly run out
         // if we don't properly time the rendering process.
-        let mut command_buffer = gpu.acquire_command_buffer();
-        if let Ok(swapchain) = gpu.wait_and_acquire_swapchain_texture(&window, &mut command_buffer)
-        {
+        let mut command_buffer = gpu.acquire_command_buffer()?;
+        if let Ok(swapchain) = command_buffer.wait_and_acquire_swapchain_texture(&window) {
             // Again, like in gpu-clear.rs, we'd want to define basic operations for our triangle
             let color_targets = [
                 sdl3::gpu::ColorTargetInfo::default()
-                    .with_texture(swapchain)
+                    .with_texture(&swapchain)
                     .with_load_op(sdl3::gpu::LoadOp::Clear)
                     .with_store_op(sdl3::gpu::StoreOp::Store)
                     .with_clear_color(sdl3::pixels::Color::RGB(5, 3, 255)), //blue with small RG bias
@@ -120,5 +117,6 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
             command_buffer.cancel();
         }
     }
+
     Ok(())
 }