WIP frames iterator

Author: jdahlstrom

core/src/math/spline.rs

@@ -3,8 +3,8 @@ use alloc::vec::Vec;
 use core::{array::from_fn, fmt::Debug, marker::PhantomData};
 
 use super::{
-    Affine, Lerp, Linear, Mat4, Parametric, Point, Vary, Vector, inv_lerp,
-    space::Real,
+    Affine, Lerp, Linear, Mat4, Parametric, Point, Point3, Vary, Vec3, Vector,
+    inv_lerp, param, space::Real,
 };
 use crate::geom::{Polyline, Ray};
 use crate::mat;
@@ -497,6 +497,39 @@ where
     }
 }
 
+impl<B> BezierSpline<Point3<B>> {
+    pub fn frame_iter(&self, step: f32) -> impl Iterator<Item = Mat4<B>> {
+        FrameIter {
+            iter: self.iter(step),
+            mat: Default::default(),
+        }
+    }
+}
+
+struct FrameIter<'a, B> {
+    iter: param::Iter<'a, Point3<B>, BezierSpline<Point3<B>>>,
+    mat: Mat4<B>,
+}
+
+impl<B> Iterator for FrameIter<'_, B> {
+    type Item = Mat4<B>;
+
+    fn next(&mut self) -> Option<Mat4<B>> {
+        let t = self.iter.t;
+        let Some(pt) = self.iter.next() else {
+            return None;
+        };
+
+        let fwd = self.iter.param.velocity(t).normalize_or_zero();
+        let up = 0.95 * self.mat.linear().col_vec(1) + 0.05 * Vec3::Y;
+        let right = up.cross(&fwd).normalize_or_zero();
+        let up = fwd.cross(&right);
+
+        self.mat = Mat4::from_affine(right, up, fwd, pt);
+        Some(self.mat.clone())
+    }
+}
+
 impl<T> HermiteSpline<T>
 where
     T: Affine<Diff: Linear<Scalar = f32> + Clone> + Clone,

demos/src/bin/crates.rs

@@ -1,12 +1,15 @@
 use core::ops::ControlFlow::*;
-
+use re::core::geom::Ray;
 use re::prelude::*;
+use std::ops::Range;
 
 use re::core::math::color::gray;
+use re::core::math::rand::{DEFAULT_RNG, DefaultRng, Distrib};
 use re::core::render::{
-    Model,
+    Model, View, World,
     cam::{FirstPerson, Fov},
     clip::Status::*,
+    debug,
     scene::Obj,
     shader,
     tex::SamplerClamp,
@@ -15,6 +18,7 @@ use re::core::render::{
 use re::core::util::{pixfmt::Rgba8888, pnm::read_pnm};
 
 use re::front::sdl2::Window;
+use re::geom::solids;
 use re::geom::solids::{Build, Cube};
 
 fn main() {
@@ -33,7 +37,7 @@ fn main() {
         |v: Vertex3<_>, mvp: &ProjMat3<_>| vertex(mvp.apply(&v.pos), v.attrib),
         |frag: Frag<Vec2>| {
             let even_odd = (frag.var.x() > 0.5) ^ (frag.var.y() > 0.5);
-            gray(if even_odd { 0.8 } else { 0.1 }).to_color4()
+            gray(if even_odd { 0.3 } else { 0.1 }).to_color4()
         },
     );
     let crate_shader = shader::new(
@@ -51,18 +55,32 @@ fn main() {
     let (w, h) = win.dims;
     let mut cam = Camera::new(win.dims)
         .transform(FirstPerson::default())
+        //.transform(Mat4::identity())
         .viewport((10..w - 10, h - 10..10))
         .perspective(Fov::Diagonal(degs(90.0)), 0.1..1000.0);
 
     let floor = floor();
     let crates = crates();
 
+    let rng = &mut DefaultRng::from_time();
+    let pts: Range<Point3<World>> =
+        pt3(-10.0, 3.0, -10.0)..pt3(10.0, 6.0, 10.0);
+    let dirs = splat(-1.0)..splat(1.0);
+
+    let rays = (pts, dirs);
+    let rays = rays
+        .samples(rng)
+        .map(|(p, d)| Ray(p, 20.0 * d))
+        .take(10);
+    let b = BezierSpline::from_rays(rays);
+    let mut bf = b.frame_iter(0.0001);
+
     win.run(|frame| {
         //
         // Camera
         //
 
-        let mut cam_vel = Vec3::zero();
+        let mut cam_vel: Vec3 = Vec3::zero();
 
         let ep = &frame.win.ev_pump;
 
@@ -79,23 +97,61 @@ fn main() {
 
         let ms = ep.relative_mouse_state();
         cam.transform.rotate(
-            turns(ms.x() as f32) * -0.001,
+            turns(ms.x() as f32) * 0.001,
             turns(ms.y() as f32) * -0.001,
         );
-        cam.transform
-            .translate(cam_vel.mul(frame.dt.as_secs_f32()));
+
+        let mat: Mat4<World> = bf.next().unwrap().to();
+
+        //cam.transform.pos = mat.origin() + 0.2 * Vec3::Y;
+        // cam.transform
+        //     .look_at(cam.transform.pos + mat.linear().col_vec(2));
+
+        //    .translate(cam_vel.mul(frame.dt.as_secs_f32()));
 
         //
         // Render
         //
 
-        let world_to_project = &cam.world_to_project();
+        //let world_to_project = &cam.world_to_project();
+
+        let world_to_project = mat
+            .inverse()
+            .then(&cam.world_to_view())
+            .then(&cam.project);
 
         let batch = Batch::new()
             .viewport(cam.viewport)
             .target(frame.buf)
             .context(frame.ctx);
 
+        // Spline
+        for m2w in b.frame_iter(0.001) {
+            let m2p: ProjMat3<World> = m2w.to().then(&world_to_project);
+
+            debug::circle::<Model>(Point3::origin(), 1.0)
+                //debug::sphere(Point3::origin(), 0.1)
+                //debug::basis(m2w)
+                //debug::ray(Point3::origin(), Vec3::Z)
+                .viewport(cam.viewport)
+                .target(frame.buf)
+                .context(frame.ctx)
+                .uniform(&scale(0.1.into()).to().then(&m2p))
+                .render();
+
+            // batch
+            //     .clone()
+            //     .mesh(&cb)
+            //     .shader(shader::new(
+            //         |v: Vertex3<_>, m2p: &ProjMat3<_>| {
+            //             vertex(m2p.apply(&v.pos), ())
+            //         },
+            //         |_| rgba(0xFF, 0, 0, 0),
+            //     ))
+            //     .uniform(&m2p)
+            //     .render();
+        }
+
         // Floor
         {
             let Obj { bbox, tf, geom } = &floor;