starting on ray intersection work

examples/select.rs

@@ -0,0 +1,167 @@
+#![feature(iter_next_chunk)]
+
+/// Example to illustrate selecting objects in 3d space
+///
+use bevy::{
+    prelude::*,
+    render::mesh::MeshVertexAttribute,
+    render::render_resource::{Extent3d, TextureDimension, TextureFormat},
+    render::{mesh::VertexAttributeValues, render_resource::VertexFormat},
+    window::PrimaryWindow,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, startup)
+        .add_systems(Update, select)
+        .run();
+}
+
+fn startup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut images: ResMut<Assets<Image>>,
+) {
+    let debug_material = materials.add(StandardMaterial {
+        base_color_texture: Some(images.add(uv_debug_texture())),
+        ..default()
+    });
+
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..default()
+    });
+
+    commands.spawn(PointLightBundle {
+        transform: Transform::from_xyz(0.0, 0.0, 5.0),
+        ..default()
+    });
+
+    commands.spawn(PbrBundle {
+        mesh: meshes.add(shape::Plane::default().into()),
+        material: debug_material.clone(),
+        transform: Transform::from_xyz(1.0, 1.0, 1.0),
+        ..default()
+    });
+
+    // commands.spawn(PbrBundle {
+    //     mesh: meshes.add(shape::Cube::default().into()),
+    //     material: debug_material.clone(),
+    //     transform: Transform::from_xyz(0.0, 0.0, 0.0),
+    //     ..default()
+    // });
+
+    // commands.spawn(PbrBundle {
+    //     mesh: meshes.add(shape::Torus::default().into()),
+    //     material: debug_material.clone(),
+    //     transform: Transform::from_xyz(3.0, 0.0, 0.0),
+    //     ..default()
+    // });
+
+    // commands.spawn(PbrBundle {
+    //     mesh: meshes.add(shape::Icosphere::default().try_into().unwrap()),
+    //     material: debug_material.clone(),
+    //     transform: Transform::from_xyz(0.0, 3.0, 0.0),
+    //     ..default()
+    // });
+}
+
+/// Creates a colorful test pattern
+fn uv_debug_texture() -> Image {
+    const TEXTURE_SIZE: usize = 8;
+
+    let mut palette: [u8; 32] = [
+        255, 102, 159, 255, 255, 159, 102, 255, 236, 255, 102, 255, 121, 255, 102, 255, 102, 255,
+        198, 255, 102, 198, 255, 255, 121, 102, 255, 255, 236, 102, 255, 255,
+    ];
+
+    let mut texture_data = [0; TEXTURE_SIZE * TEXTURE_SIZE * 4];
+    for y in 0..TEXTURE_SIZE {
+        let offset = TEXTURE_SIZE * y * 4;
+        texture_data[offset..(offset + TEXTURE_SIZE * 4)].copy_from_slice(&palette);
+        palette.rotate_right(4);
+    }
+
+    Image::new_fill(
+        Extent3d {
+            width: TEXTURE_SIZE as u32,
+            height: TEXTURE_SIZE as u32,
+            depth_or_array_layers: 1,
+        },
+        TextureDimension::D2,
+        &texture_data,
+        TextureFormat::Rgba8UnormSrgb,
+    )
+}
+
+fn select(
+    query: Query<(Entity, &Handle<Mesh>, &GlobalTransform)>,
+    meshes: Res<Assets<Mesh>>,
+    cameras: Query<(&Camera, &GlobalTransform)>,
+    windows: Query<&Window, With<PrimaryWindow>>,
+) {
+    // TODO:
+    // When mouse moves
+    // Ray trace to find object being selected
+    windows.iter().for_each(|window| {
+        if let Some(pos) = window.cursor_position() {
+            cameras.iter().for_each(|(camera, gt)| {
+                if let Some(ray) = camera.viewport_to_world(gt, pos) {
+                    query
+                        .iter()
+                        .filter_map(|(entity, handle, gt)| {
+                            meshes.get(handle).map(|mesh| (entity, mesh, gt))
+                        })
+                        .for_each(|(entity, mesh, gt)| {
+                            let hit = intersects(&ray, &gt, mesh);
+                            if hit.is_some() {
+                                info!("We got a hit at {:?}", entity);
+                            }
+                        });
+                }
+            });
+        }
+    });
+    panic!("Lol");
+}
+
+fn intersects(ray: &Ray, gt: &GlobalTransform, mesh: &Mesh) -> Option<f32> {
+    info!("Ray: {:#?}", ray);
+    let attr = MeshVertexAttribute::new("Vertex_Position", 0, VertexFormat::Float32x3);
+    if let Some(verts) = mesh.attribute(attr) {
+        if let Some(idxs) = mesh.indices() {
+            match verts {
+                VertexAttributeValues::Float32x3(vals) => {
+                    let mut itr = idxs.iter();
+                    while let Ok(points) = itr
+                        .next_chunk::<3>()
+                        .map(|[x, y, z]| {
+                            [
+                                Vec3::from_array(vals[x]),
+                                Vec3::from_array(vals[y]),
+                                Vec3::from_array(vals[z]),
+                            ]
+                        })
+                        .map(|[a, b, c]| {
+                            [
+                                gt.transform_point(a),
+                                gt.transform_point(b),
+                                gt.transform_point(c),
+                            ]
+                        })
+                    {
+                        info!("Does ray intersect with points: {:?}", points);
+                        // OK so I have a ray with an origin and direction
+                        // And I have a triangle made of 3 points
+                        // How do I test if ray intersects with tri???
+                    }
+                }
+                _ => warn!("Unrecognized indexes"),
+            }
+        }
+    }
+
+    None
+}