fix: Address most Clippy warnings

examples/bindless/main.rs

@@ -70,7 +70,7 @@ fn main() {
         let textures = (0..BINDLESS_TEXTURE_COUNT)
             .map(|i| {
                 heap.new_texture(&texture_descriptor)
-                    .expect(&format!("Failed to allocate texture {}", i))
+                    .unwrap_or_else(|| panic!("Failed to allocate texture {}", i))
             })
             .collect::<Vec<_>>();
 

examples/circle/main.rs

@@ -11,18 +11,18 @@ use core_graphics_types::geometry::CGSize;
 
 use objc::{rc::autoreleasepool, runtime::YES};
 
-use std::mem;
-
 // Declare the data structures needed to carry vertex layout to
 // metal shading language(MSL) program. Use #[repr(C)], to make
 // the data structure compatible with C++ type data structure
 // for vertex defined in MSL program as MSL program is broadly
 // based on C++
 #[repr(C)]
 #[derive(Debug)]
+#[allow(non_camel_case_types)]
 pub struct position(cty::c_float, cty::c_float);
 #[repr(C)]
 #[derive(Debug)]
+#[allow(non_camel_case_types)]
 pub struct color(cty::c_float, cty::c_float, cty::c_float);
 #[repr(C)]
 #[derive(Debug)]
@@ -52,7 +52,7 @@ fn main() {
     device.sample_timestamps(&mut cpu_start, &mut gpu_start);
     let counter_sample_buffer = create_counter_sample_buffer(&device);
     let destination_buffer = device.new_buffer(
-        (std::mem::size_of::<u64>() * 4 as usize) as u64,
+        (std::mem::size_of::<u64>() * 4_usize) as u64,
         MTLResourceOptions::StorageModeShared,
     );
     let counter_sampling_point = MTLCounterSamplingPoint::AtStageBoundary;
@@ -102,7 +102,7 @@ fn main() {
     unsafe {
         let view = window.ns_view() as cocoa_id;
         view.setWantsLayer(YES);
-        view.setLayer(mem::transmute(layer.as_ref()));
+        view.setLayer(std::ptr::from_ref(layer.as_ref()).cast_mut().cast());
     }
 
     let draw_size = window.inner_size();
@@ -114,7 +114,7 @@ fn main() {
 
         device.new_buffer_with_data(
             vertex_data.as_ptr() as *const _,
-            (vertex_data.len() * mem::size_of::<AAPLVertex>()) as u64,
+            std::mem::size_of_val(vertex_data) as u64,
             MTLResourceOptions::CPUCacheModeDefaultCache | MTLResourceOptions::StorageModeManaged,
         )
     };
@@ -152,18 +152,14 @@ fn main() {
 
                     // Obtain a renderPassDescriptor generated from the view's drawable textures.
                     let render_pass_descriptor = RenderPassDescriptor::new();
-                    handle_render_pass_color_attachment(
-                        &render_pass_descriptor,
-                        drawable.texture(),
-                    );
+                    handle_render_pass_color_attachment(render_pass_descriptor, drawable.texture());
                     handle_render_pass_sample_buffer_attachment(
-                        &render_pass_descriptor,
+                        render_pass_descriptor,
                         &counter_sample_buffer,
                     );
 
                     // Create a render command encoder.
-                    let encoder =
-                        command_buffer.new_render_command_encoder(&render_pass_descriptor);
+                    let encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);
                     encoder.set_render_pipeline_state(&pipeline_state);
                     // Pass in the parameter data.
                     encoder.set_vertex_buffer(0, Some(&vbuf), 0);
@@ -172,13 +168,13 @@ fn main() {
                     encoder.end_encoding();
 
                     resolve_samples_into_buffer(
-                        &command_buffer,
+                        command_buffer,
                         &counter_sample_buffer,
                         &destination_buffer,
                     );
 
                     // Schedule a present once the framebuffer is complete using the current drawable.
-                    command_buffer.present_drawable(&drawable);
+                    command_buffer.present_drawable(drawable);
 
                     // Finalize rendering here & push the command buffer to the GPU.
                     command_buffer.commit();
@@ -247,7 +243,7 @@ fn handle_render_pass_sample_buffer_attachment(
 ) {
     let sample_buffer_attachment_descriptor =
         descriptor.sample_buffer_attachments().object_at(0).unwrap();
-    sample_buffer_attachment_descriptor.set_sample_buffer(&counter_sample_buffer);
+    sample_buffer_attachment_descriptor.set_sample_buffer(counter_sample_buffer);
     sample_buffer_attachment_descriptor.set_start_of_vertex_sample_index(0 as NSUInteger);
     sample_buffer_attachment_descriptor.set_end_of_vertex_sample_index(1 as NSUInteger);
     sample_buffer_attachment_descriptor.set_start_of_fragment_sample_index(2 as NSUInteger);
@@ -300,9 +296,9 @@ fn resolve_samples_into_buffer(
 ) {
     let blit_encoder = command_buffer.new_blit_command_encoder();
     blit_encoder.resolve_counters(
-        &counter_sample_buffer,
+        counter_sample_buffer,
         crate::NSRange::new(0_u64, 4),
-        &destination_buffer,
+        destination_buffer,
         0_u64,
     );
     blit_encoder.end_encoding();
@@ -316,7 +312,7 @@ fn handle_timestamps(
     gpu_end: u64,
 ) {
     let samples = unsafe {
-        std::slice::from_raw_parts(resolved_sample_buffer.contents() as *const u64, 4 as usize)
+        std::slice::from_raw_parts(resolved_sample_buffer.contents() as *const u64, 4_usize)
     };
     let vertex_pass_start = samples[0];
     let vertex_pass_end = samples[1];
@@ -372,6 +368,6 @@ fn fetch_timestamp_counter_set(device: &Device) -> metal::CounterSet {
 fn microseconds_between_begin(begin: u64, end: u64, gpu_time_span: u64, cpu_time_span: u64) -> f64 {
     let time_span = (end as f64) - (begin as f64);
     let nanoseconds = time_span / (gpu_time_span as f64) * (cpu_time_span as f64);
-    let microseconds = nanoseconds / 1000.0;
-    return microseconds;
+    const NS_TO_MS: f64 = 1. / 1000.;
+    nanoseconds * NS_TO_MS
 }

examples/headless-render/main.rs

@@ -16,8 +16,8 @@ const VIEW_WIDTH: u64 = 512;
 const VIEW_HEIGHT: u64 = 512;
 const TOTAL_BYTES: usize = (VIEW_WIDTH * VIEW_HEIGHT * 4) as usize;
 
-const VERTEX_SHADER: &'static str = "triangle_vertex";
-const FRAGMENT_SHADER: &'static str = "triangle_fragment";
+const VERTEX_SHADER: &str = "triangle_vertex";
+const FRAGMENT_SHADER: &str = "triangle_fragment";
 
 // [2 bytes position, 3 bytes color] * 3
 #[rustfmt::skip]
@@ -54,10 +54,10 @@ fn main() {
     let vertex_buffer = create_vertex_buffer(&device);
 
     let render_pass_descriptor = RenderPassDescriptor::new();
-    initialize_color_attachment(&render_pass_descriptor, &texture);
+    initialize_color_attachment(render_pass_descriptor, &texture);
 
     let command_buffer = command_queue.new_command_buffer();
-    let rc_encoder = command_buffer.new_render_command_encoder(&render_pass_descriptor);
+    let rc_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);
     rc_encoder.set_render_pipeline_state(&pipeline_state);
     rc_encoder.set_vertex_buffer(0, Some(&vertex_buffer), 0);
     rc_encoder.draw_primitives(MTLPrimitiveType::Triangle, 0, 3);
@@ -100,7 +100,7 @@ fn save_image(texture: &TextureRef) {
     let out_file =
         PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("examples/headless-render/out.png");
     let file = File::create(&out_file).unwrap();
-    let ref mut w = BufWriter::new(file);
+    let w = &mut BufWriter::new(file);
 
     let mut encoder = png::Encoder::new(w, VIEW_WIDTH as u32, VIEW_HEIGHT as u32);
     encoder.set_color(ColorType::Rgba);

examples/library/main.rs

@@ -7,7 +7,7 @@
 
 use metal::*;
 
-const PROGRAM: &'static str = "";
+const PROGRAM: &str = "";
 
 fn main() {
     let device = Device::system_default().expect("no device found");

examples/mesh-shader/main.rs

@@ -5,7 +5,6 @@ use core_graphics_types::geometry::CGSize;
 
 use metal::*;
 use objc::{rc::autoreleasepool, runtime::YES};
-use std::mem;
 use winit::platform::macos::WindowExtMacOS;
 
 use winit::{
@@ -42,7 +41,7 @@ fn main() {
     unsafe {
         let view = window.ns_view() as cocoa_id;
         view.setWantsLayer(YES);
-        view.setLayer(mem::transmute(layer.as_ref()));
+        view.setLayer(std::ptr::from_ref(layer.as_ref()).cast_mut().cast());
     }
 
     let draw_size = window.inner_size();
@@ -93,11 +92,10 @@ fn main() {
 
                     let render_pass_descriptor = RenderPassDescriptor::new();
 
-                    prepare_render_pass_descriptor(&render_pass_descriptor, drawable.texture());
+                    prepare_render_pass_descriptor(render_pass_descriptor, drawable.texture());
 
                     let command_buffer = command_queue.new_command_buffer();
-                    let encoder =
-                        command_buffer.new_render_command_encoder(&render_pass_descriptor);
+                    let encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);
 
                     encoder.set_render_pipeline_state(&pipeline_state);
                     encoder.draw_mesh_threads(
@@ -108,7 +106,7 @@ fn main() {
 
                     encoder.end_encoding();
 
-                    command_buffer.present_drawable(&drawable);
+                    command_buffer.present_drawable(drawable);
                     command_buffer.commit();
                 }
                 _ => {}

examples/mps/main.rs

@@ -114,7 +114,7 @@ fn main() {
 
     // Intersect rays with triangles inside acceleration structure
     ray_intersector.encode_intersection_to_command_buffer(
-        &command_buffer,
+        command_buffer,
         mps::MPSIntersectionType::Nearest,
         &ray_buffer,
         0,
@@ -140,9 +140,7 @@ fn create_pipeline(func: &str, library: &LibraryRef, device: &DeviceRef) -> Comp
     let function = library.get_function(func, None).unwrap();
     compute_descriptor.set_compute_function(Some(&function));
 
-    let pipeline = device
+    device
         .new_compute_pipeline_state(&compute_descriptor)
-        .unwrap();
-
-    pipeline
+        .unwrap()
 }

examples/raytracing/camera.rs

@@ -8,6 +8,12 @@ pub struct Camera {
     pub forward: Vec4,
 }
 
+impl Default for Camera {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Camera {
     pub fn new() -> Self {
         Self {

examples/raytracing/geometry.rs

@@ -44,7 +44,7 @@ pub trait Geometry {
 pub fn compute_triangle_normal(v0: &Vec3, v1: &Vec3, v2: &Vec3) -> Vec3 {
     let e1 = Vec3::normalize(*v1 - *v0);
     let e2 = Vec3::normalize(*v2 - *v0);
-    return Vec3::cross(e1, e2);
+    Vec3::cross(e1, e2)
 }
 
 #[derive(Default)]
@@ -55,7 +55,7 @@ pub struct Triangle {
 }
 
 pub fn get_managed_buffer_storage_mode() -> MTLResourceOptions {
-    return MTLResourceOptions::StorageModeManaged;
+    MTLResourceOptions::StorageModeManaged
 }
 
 pub struct TriangleGeometry {
@@ -91,6 +91,7 @@ impl TriangleGeometry {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn add_cube_face_with_cube_vertices(
         &mut self,
         cube_vertices: &[Vec3],
@@ -112,10 +113,10 @@ impl TriangleGeometry {
         let first_index = self.indices.len();
         let base_index = self.vertices.len() as u16;
 
-        self.indices.push(base_index + 0);
+        self.indices.push(base_index);
         self.indices.push(base_index + 1);
         self.indices.push(base_index + 2);
-        self.indices.push(base_index + 0);
+        self.indices.push(base_index);
         self.indices.push(base_index + 2);
         self.indices.push(base_index + 3);
 
@@ -164,10 +165,10 @@ impl TriangleGeometry {
             Vec3::new(0.5, 0.5, 0.5),
         ];
 
-        for i in 0..8 {
-            let transformed_vertex = Vec4::from((cube_vertices[i], 1.0));
+        for vertex in &mut cube_vertices {
+            let transformed_vertex = Vec4::from((*vertex, 1.0));
             let transformed_vertex = transform * transformed_vertex;
-            cube_vertices[i] = transformed_vertex.xyz();
+            *vertex = transformed_vertex.xyz();
         }
 
         const CUBE_INDICES: [[u16; 4]; 6] = [
@@ -179,15 +180,15 @@ impl TriangleGeometry {
             [4, 5, 7, 6],
         ];
 
-        for face in 0..6 {
+        for (face, cube) in CUBE_INDICES.iter().enumerate() {
             if face_mask & (1 << face) != 0 {
                 self.add_cube_face_with_cube_vertices(
                     &cube_vertices,
                     colour,
-                    CUBE_INDICES[face][0],
-                    CUBE_INDICES[face][1],
-                    CUBE_INDICES[face][2],
-                    CUBE_INDICES[face][3],
+                    cube[0],
+                    cube[1],
+                    cube[2],
+                    cube[3],
                     inward_normals,
                 );
             }
@@ -416,14 +417,14 @@ impl Geometry for SphereGeometry {
         let descriptor = AccelerationStructureBoundingBoxGeometryDescriptor::descriptor();
         descriptor.set_bounding_box_buffer(Some(self.bounding_box_buffer.as_ref().unwrap()));
         descriptor.set_bounding_box_count(self.spheres.len() as NSUInteger);
-        descriptor.set_primitive_data_buffer(Some(&self.sphere_buffer.as_ref().unwrap()));
+        descriptor.set_primitive_data_buffer(Some(self.sphere_buffer.as_ref().unwrap()));
         descriptor.set_primitive_data_stride(size_of::<Sphere>() as NSUInteger);
         descriptor.set_primitive_data_element_size(size_of::<Sphere>() as NSUInteger);
         From::from(descriptor)
     }
 
     fn get_resources(&self) -> Vec<Resource> {
-        return vec![From::from(self.sphere_buffer.as_ref().unwrap().clone())];
+        vec![From::from(self.sphere_buffer.as_ref().unwrap().clone())]
     }
 
     fn get_intersection_function_name(&self) -> Option<&str> {
@@ -432,7 +433,7 @@ impl Geometry for SphereGeometry {
 }
 
 pub struct GeometryInstance {
-    pub geometry: Arc<dyn Geometry>,
+    pub geometry: Arc<dyn Geometry + Send + Sync>,
     pub transform: Mat4,
     pub mask: u32,
     pub index_in_scene: NSUInteger,

examples/raytracing/main.rs

@@ -4,7 +4,6 @@ use cocoa::{appkit::NSView, base::id as cocoa_id};
 use core_graphics_types::geometry::CGSize;
 use metal::*;
 use objc::{rc::autoreleasepool, runtime::YES};
-use std::mem;
 use winit::{
     event::{Event, WindowEvent},
     event_loop::ControlFlow,
@@ -50,7 +49,7 @@ fn main() {
     unsafe {
         let view = window.ns_view() as cocoa_id;
         view.setWantsLayer(YES);
-        view.setLayer(mem::transmute(layer.as_ref()));
+        view.setLayer(std::ptr::from_ref(layer.as_ref()).cast_mut().cast());
     }
 
     let draw_size = window.inner_size();