Vendor things

third-party/vendor/metal/examples/raytracing/scene.rs

@@ -0,0 +1,135 @@
+use std::{ffi::c_void, mem::size_of, sync::Arc};
+
+use glam::{Mat4, Vec3, Vec4};
+use rand::{thread_rng, Rng};
+
+use metal::{Buffer, Device, NSRange, NSUInteger};
+
+use super::{camera::Camera, geometry::*};
+
+pub struct Scene {
+    pub device: Device,
+    pub camera: Camera,
+    pub geometries: Vec<Arc<dyn Geometry>>,
+    pub geometry_instances: Vec<Arc<GeometryInstance>>,
+    pub lights: Vec<AreaLight>,
+    pub lights_buffer: Buffer,
+}
+
+impl Scene {
+    pub fn new(device: Device) -> Self {
+        let mut geometries = Vec::<Arc<dyn Geometry>>::new();
+        let mut light_mesh = TriangleGeometry::new(device.clone(), "light".to_string());
+        let transform = Mat4::from_translation(Vec3::new(0.0, 1.0, 0.0))
+            * Mat4::from_scale(Vec3::new(0.5, 1.98, 0.5));
+        light_mesh.add_cube_with_faces(
+            FACE_MASK_POSITIVE_Y,
+            Vec3::new(1.0, 1.0, 1.0),
+            transform,
+            true,
+        );
+        light_mesh.upload_to_buffers();
+        let light_mesh = Arc::new(light_mesh);
+        geometries.push(light_mesh.clone());
+
+        let mut geometry_mesh = TriangleGeometry::new(device.clone(), "geometry".to_string());
+        let transform = Mat4::from_translation(Vec3::new(0.0, 1.0, 0.0))
+            * Mat4::from_scale(Vec3::new(2.0, 2.0, 2.0));
+        geometry_mesh.add_cube_with_faces(
+            FACE_MASK_NEGATIVE_Y | FACE_MASK_POSITIVE_Y | FACE_MASK_NEGATIVE_Z,
+            Vec3::new(0.725, 0.71, 0.68),
+            transform,
+            true,
+        );
+        geometry_mesh.add_cube_with_faces(
+            FACE_MASK_NEGATIVE_X,
+            Vec3::new(0.63, 0.065, 0.05),
+            transform,
+            true,
+        );
+        geometry_mesh.add_cube_with_faces(
+            FACE_MASK_POSITIVE_X,
+            Vec3::new(0.14, 0.45, 0.091),
+            transform,
+            true,
+        );
+        let transform = Mat4::from_translation(Vec3::new(-0.335, 0.6, -0.29))
+            * Mat4::from_rotation_y(0.3)
+            * Mat4::from_scale(Vec3::new(0.6, 1.2, 0.6));
+        geometry_mesh.add_cube_with_faces(
+            FACE_MASK_ALL,
+            Vec3::new(0.725, 0.71, 0.68),
+            transform,
+            false,
+        );
+        geometry_mesh.upload_to_buffers();
+        let geometry_mesh = Arc::new(geometry_mesh);
+        geometries.push(geometry_mesh.clone());
+
+        let mut sphere_geometry = SphereGeometry::new(device.clone());
+        sphere_geometry.add_sphere_with_origin(
+            Vec3::new(0.3275, 0.3, 0.3725),
+            0.3,
+            Vec3::new(0.725, 0.71, 0.68),
+        );
+        sphere_geometry.upload_to_buffers();
+        let sphere_geometry = Arc::new(sphere_geometry);
+        geometries.push(sphere_geometry.clone());
+
+        let mut rng = thread_rng();
+        let mut geometry_instances = Vec::new();
+        let mut lights = Vec::new();
+        for y in -1..2 {
+            for x in -1..2 {
+                let transform =
+                    Mat4::from_translation(Vec3::new(x as f32 * 2.5, y as f32 * 2.5, 0.0));
+                geometry_instances.push(Arc::new(GeometryInstance {
+                    geometry: light_mesh.clone(),
+                    transform,
+                    mask: GEOMETRY_MASK_LIGHT,
+                    index_in_scene: 0,
+                }));
+                geometry_instances.push(Arc::new(GeometryInstance {
+                    geometry: geometry_mesh.clone(),
+                    transform,
+                    mask: GEOMETRY_MASK_TRIANGLE,
+                    index_in_scene: 1,
+                }));
+                geometry_instances.push(Arc::new(GeometryInstance {
+                    geometry: sphere_geometry.clone(),
+                    transform,
+                    mask: GEOMETRY_MASK_SPHERE,
+                    index_in_scene: 2,
+                }));
+                lights.push(AreaLight {
+                    position: Vec4::new(x as f32 * 2.5, y as f32 * 2.5 + 1.98, 0.0, 0.0),
+                    forward: Vec4::new(0.0, -1.0, 0.0, 0.0),
+                    right: Vec4::new(0.25, 0.0, 0.0, 0.0),
+                    up: Vec4::new(0.0, 0.0, 0.25, 0.0),
+                    colour: Vec4::new(
+                        rng.gen_range(0f32..=1.0),
+                        rng.gen_range(0f32..=1.0),
+                        rng.gen_range(0f32..=1.0),
+                        0.0,
+                    ),
+                });
+            }
+        }
+        let lights_buffer = device.new_buffer_with_data(
+            lights.as_ptr() as *const c_void,
+            (lights.len() * size_of::<AreaLight>()) as NSUInteger,
+            get_managed_buffer_storage_mode(),
+        );
+        lights_buffer.did_modify_range(NSRange::new(0, lights_buffer.length()));
+        lights_buffer.set_label("lights buffer");
+
+        Self {
+            device,
+            camera: Camera::new(),
+            geometries,
+            geometry_instances,
+            lights,
+            lights_buffer,
+        }
+    }
+}