Genericize puzzle state and animation

I need Rust v1.86.0 (currently beta) for rust-lang/rust#134540

Author: HactarCE

Cargo.toml

@@ -24,7 +24,7 @@ documentation = "https://dev.hypercubing.xyz/internals/"
 edition = "2024"
 homepage = "https://ajfarkas.dev/projects/hyperspeedcube/"
 repository = "https://github.com/HactarCE/Hyperspeedcube/"
-rust-version = "1.85.0"
+rust-version = "1.86.0"
 
 [workspace.lints.rust]
 missing_docs = "warn"

crates/hyperprefs/src/filters/mod.rs

@@ -1,6 +1,7 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
 use std::fmt;
 use std::sync::Arc;
-use std::{borrow::Cow, collections::HashMap};
 
 use hyperpuzzle_core::{PieceMask, Puzzle};
 use itertools::Itertools;

crates/hyperpuzzle_core/src/lib.rs

@@ -7,10 +7,12 @@ mod catalog;
 mod lint;
 mod logging;
 mod nameable;
+mod nongeneric;
 mod puzzle;
 mod rgb;
 mod tags;
 mod timestamp;
+mod traits;
 pub mod util;
 mod version;
 
@@ -20,10 +22,12 @@ pub use chrono;
 pub use lint::PuzzleLintOutput;
 pub use logging::*;
 pub use nameable::*;
+pub use nongeneric::*;
 pub use puzzle::*;
 pub use rgb::Rgb;
 pub use tags::*;
 pub use timestamp::Timestamp;
+pub use traits::*;
 pub use version::Version;
 
 /// Unsigned integer type used for [`LayerMask`].

crates/hyperpuzzle_core/src/nongeneric.rs

@@ -0,0 +1,37 @@
+use hypermath::pga;
+
+use crate::{BoxDynPuzzleAnimation, PerPiece, PieceMask, PuzzleAnimation, PuzzleStateRenderData};
+
+// /// Data that needs to be uploaded to the GPU before rendering.
+// pub enum PuzzleTypeGpuBuffers {
+//     /// N-dimensional Euclidean mesh data.
+//     Hypershape(),
+//     /// No GPU data
+//     None,
+// }
+
+/// Puzzle render data for an N-dimensional Euclidean puzzle.
+pub struct NdEuclidPuzzleStateRenderData {
+    /// Transform for each piece.
+    pub piece_transforms: PerPiece<pga::Motor>,
+}
+impl PuzzleStateRenderData for NdEuclidPuzzleStateRenderData {}
+
+#[derive(Debug, Clone)]
+pub struct NdEuclidPuzzleAnimation {
+    /// Set of pieces affected by the animation.
+    pub pieces: PieceMask,
+    /// Initial transform of the pieces (identity, unless the move was inputted
+    /// using a mouse drag).
+    pub initial_transform: pga::Motor,
+    /// Final transform for the pieces.
+    pub final_transform: pga::Motor,
+}
+impl PuzzleAnimation for NdEuclidPuzzleAnimation {
+    fn dyn_clone(&self) -> BoxDynPuzzleAnimation
+    where
+        Self: Sized,
+    {
+        self.clone().into()
+    }
+}

crates/hyperpuzzle_core/src/puzzle/mod.rs

@@ -22,5 +22,5 @@ pub use notation::Notation;
 pub use piece_type_hierarchy::*;
 pub use puzzle_type::{PLACEHOLDER_PUZZLE, Puzzle};
 pub use scramble::{ScrambleParams, ScrambleProgress, ScrambleType, ScrambledPuzzle};
-pub use state::PuzzleState;
+pub use state::HypershapePuzzleState;
 pub use twist::LayeredTwist;

crates/hyperpuzzle_core/src/puzzle/puzzle_type.rs

@@ -41,7 +41,7 @@ lazy_static! {
         gizmo_twists: PerGizmoFace::new(),
         dev_data: PuzzleDevData::new(),
 
-        new: Box::new(PuzzleState::new),
+        new: Box::new(HypershapePuzzleState::new),
     });
 }
 
@@ -99,7 +99,7 @@ pub struct Puzzle {
     pub dev_data: PuzzleDevData,
 
     /// Constructor for a solved puzzle state.
-    pub new: Box<dyn Send + Sync + Fn(Arc<Self>) -> PuzzleState>,
+    pub new: Box<dyn Send + Sync + Fn(Arc<Self>) -> HypershapePuzzleState>,
 }
 
 impl fmt::Debug for Puzzle {
@@ -138,7 +138,7 @@ impl Puzzle {
         self.this.upgrade().expect("`Puzzle` removed from `Arc`")
     }
     /// Constructs a new instance of the puzzle.
-    pub fn new_solved_state(&self) -> PuzzleState {
+    pub fn new_solved_state(&self) -> HypershapePuzzleState {
         (self.new)(self.arc())
     }
     /// Constructs a new scrambled instance of the puzzle.

crates/hyperpuzzle_core/src/puzzle/scramble.rs

@@ -3,7 +3,7 @@ use std::sync::atomic::{AtomicBool, AtomicU32};
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 
-use super::{LayeredTwist, PuzzleState};
+use super::{HypershapePuzzleState, LayeredTwist};
 use crate::Timestamp;
 
 /// Parameters to deterministically generate a twist sequence to scramble a
@@ -96,5 +96,5 @@ pub struct ScrambledPuzzle {
     /// Scramble twists applied.
     pub twists: Vec<LayeredTwist>,
     /// State of the puzzle after scrambling.
-    pub state: PuzzleState,
+    pub state: HypershapePuzzleState,
 }

crates/hyperpuzzle_core/src/puzzle/state.rs

@@ -7,7 +7,11 @@ use hypermath::prelude::*;
 use itertools::Itertools;
 use parking_lot::Mutex;
 
-use crate::{Axis, AxisInfo, LayerMask, LayeredTwist, PerAxis, PerPiece, Piece, PieceMask, Puzzle};
+use crate::{
+    Axis, AxisInfo, BoxDynPuzzleAnimation, BoxDynPuzzleStateRenderData, LayerMask, LayeredTwist,
+    NdEuclidPuzzleAnimation, NdEuclidPuzzleStateRenderData, PerAxis, PerPiece, Piece, PieceMask,
+    Puzzle, PuzzleState,
+};
 
 type PerCachedTransform<T> = GenericVec<CachedTransform, T>;
 idx_struct! {
@@ -39,7 +43,7 @@ impl CachedTransformData {
 
 /// Instance of a puzzle with a particular state.
 #[derive(Debug, Clone)]
-pub struct PuzzleState {
+pub struct HypershapePuzzleState {
     /// Immutable puzzle type info.
     puzzle_type: Arc<Puzzle>,
     /// Attitude (position & rotation) of each piece.
@@ -48,7 +52,47 @@ pub struct PuzzleState {
     cached_transforms: Arc<Mutex<PerCachedTransform<CachedTransformData>>>,
     cached_transform_by_motor: Arc<Mutex<ApproxHashMap<pga::Motor, CachedTransform>>>,
 }
-impl PuzzleState {
+
+impl PuzzleState for HypershapePuzzleState {
+    fn ty(&self) -> &Arc<Puzzle> {
+        &self.puzzle_type
+    }
+
+    fn render_data(&self) -> BoxDynPuzzleStateRenderData {
+        NdEuclidPuzzleStateRenderData {
+            piece_transforms: self.piece_transforms(),
+        }
+        .into()
+    }
+
+    fn render_data_with_animation(
+        &self,
+        anim: &BoxDynPuzzleAnimation,
+        t: f32,
+    ) -> BoxDynPuzzleStateRenderData {
+        let anim = anim
+            .downcast_ref::<NdEuclidPuzzleAnimation>()
+            .expect("invalid animation for puzzle");
+
+        let start = &anim.initial_transform;
+        let end = &anim.final_transform;
+        let m = if t == 0.0 {
+            start.clone()
+        } else if t == 1.0 {
+            end.clone()
+        } else {
+            pga::Motor::slerp_infallible(start, end, t as _)
+        };
+
+        let mut piece_transforms = self.piece_transforms();
+        for piece in anim.pieces.iter() {
+            piece_transforms[piece] = &m * &piece_transforms[piece];
+        }
+        NdEuclidPuzzleStateRenderData { piece_transforms }.into()
+    }
+}
+
+impl HypershapePuzzleState {
     /// Constructs a new instance of a puzzle.
     pub fn new(puzzle_type: Arc<Puzzle>) -> Self {
         let ident = pga::Motor::ident(puzzle_type.ndim());
@@ -62,36 +106,19 @@ impl PuzzleState {
         by_motor.insert(ident, CachedTransform(0));
         let cached_transform_by_motor = Arc::new(Mutex::new(by_motor));
 
-        PuzzleState {
+        HypershapePuzzleState {
             puzzle_type,
             piece_transforms,
             cached_transforms,
             cached_transform_by_motor,
         }
     }
-    /// Returns the puzzle type
-    pub fn ty(&self) -> &Arc<Puzzle> {
-        &self.puzzle_type
-    }
     /// Returns the position and rotation of each piece.
-    pub fn piece_transforms(&self) -> PerPiece<pga::Motor> {
+    pub(crate) fn piece_transforms(&self) -> PerPiece<pga::Motor> {
         let cached = self.cached_transforms.lock();
         self.piece_transforms
             .map_ref(|_, &i| cached[i].motor.clone())
     }
-    /// Returns the position and rotation of each piece during an arbitrary
-    /// animation affecting a subset of pieces.
-    pub fn partial_piece_transforms(
-        &self,
-        grip: &PieceMask,
-        transform: &pga::Motor,
-    ) -> PerPiece<pga::Motor> {
-        self.piece_transforms()
-            .map(|piece, static_transform| match grip.contains(piece) {
-                true => transform * static_transform,
-                _ => static_transform.clone(),
-            })
-    }
 
     /// Does a twist, or returns an error containing the set of pieces that
     /// prevented the twist.

crates/hyperpuzzle_core/src/traits.rs

@@ -0,0 +1,76 @@
+use std::any::Any;
+use std::fmt;
+use std::sync::Arc;
+
+use crate::Puzzle;
+
+/// Instance of a puzzle with a particular state.
+///
+/// In order to be dyn-compatible, this trait has no associated types. Instead
+/// it uses `Box<dyn Any>` for rendering data. All implementors of this trait
+/// should explicitly document which type(s) may be returned from
+/// [`PuzzleState::render_data()`].
+pub trait PuzzleState: 'static + fmt::Debug + Clone + Send + Sync {
+    /// Returns the puzzle type.
+    fn ty(&self) -> &Arc<Puzzle>;
+
+    /// Returns data to render the current state of the puzzle.
+    fn render_data(&self) -> BoxDynPuzzleStateRenderData;
+    /// Returns data to render the state of the puzzle during an animation.
+    ///
+    /// `t` ranges from 0 to 1. Motion should be perceptually linear with
+    /// respect to `t`.
+    ///
+    /// # Panics
+    ///
+    /// This method may panics if passed an invalid animation.
+    fn render_data_with_animation(
+        &self,
+        anim: &BoxDynPuzzleAnimation,
+        t: f32,
+    ) -> BoxDynPuzzleStateRenderData;
+}
+
+macro_rules! box_dyn_wrapper_struct {
+    ($vis:vis struct $struct_name:ident(Box<dyn $trait_name:ident>)) => {
+        $vis struct $struct_name(Box<dyn $trait_name>);
+        impl fmt::Debug for $struct_name {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.debug_tuple(stringify!($struct_name))
+                    .finish_non_exhaustive()
+            }
+        }
+        impl<T: $trait_name> From<T> for $struct_name {
+            fn from(value: T) -> Self {
+                Self(Box::new(value))
+            }
+        }
+        impl $struct_name {
+            pub fn downcast<T: $trait_name>(self) -> Option<Box<T>> {
+                (self.0 as Box<dyn Any>).downcast().ok()
+            }
+            pub fn downcast_ref<T: $trait_name>(&self) -> Option<&T> {
+                (&*self.0 as &dyn Any).downcast_ref()
+            }
+        }
+    };
+}
+
+/// Marker trait for types that may be returned from
+/// [`PuzzleState::render_data()`].
+///
+/// Because [`Any`] is defined with a `'static` bound, implementors of this
+/// trait cannot borrow from the puzzle state.
+pub trait PuzzleStateRenderData: Any + Send + Sync {}
+box_dyn_wrapper_struct!(pub struct BoxDynPuzzleStateRenderData(Box<dyn PuzzleStateRenderData>));
+
+/// Marker trait for types that may be used as animations.
+pub trait PuzzleAnimation: Any + Send + Sync {
+    fn dyn_clone(&self) -> BoxDynPuzzleAnimation;
+}
+box_dyn_wrapper_struct!(pub struct BoxDynPuzzleAnimation(Box<dyn PuzzleAnimation>));
+impl Clone for BoxDynPuzzleAnimation {
+    fn clone(&self) -> Self {
+        self.0.dyn_clone()
+    }
+}

crates/hyperpuzzle_lua/src/builder/puzzle.rs

@@ -132,7 +132,7 @@ impl PuzzleBuilder {
 
             dev_data,
 
-            new: Box::new(PuzzleState::new),
+            new: Box::new(HypershapePuzzleState::new),
         }))
     }
 }

crates/hyperpuzzle_view/src/animations/twist.rs

@@ -1,8 +1,7 @@
 use std::collections::VecDeque;
 
-use hypermath::pga;
 use hyperprefs::AnimationPreferences;
-use hyperpuzzle_core::{PieceMask, PuzzleState};
+use hyperpuzzle_core::{BoxDynPuzzleAnimation, HypershapePuzzleState};
 use web_time::Duration;
 
 /// If at least this much of a twist is animated in one frame, just skip the
@@ -15,7 +14,7 @@ const EXP_TWIST_FACTOR: f32 = 0.5;
 #[derive(Debug, Default, Clone)]
 pub struct TwistAnimationState {
     /// Queue of twist animations to be displayed.
-    queue: VecDeque<TwistAnimation>,
+    queue: VecDeque<AnimationFromState>,
     /// Maximum number of animations in the queue (reset when queue is empty).
     queue_max: usize,
     /// Progress of the animation in the current twist, from 0.0 to 1.0.
@@ -57,27 +56,22 @@ impl TwistAnimationState {
         }
     }
 
-    pub fn push(&mut self, anim: TwistAnimation) {
+    pub fn push(&mut self, anim: AnimationFromState) {
         self.queue.push_back(anim);
 
         // Update queue_max.
         self.queue_max = std::cmp::max(self.queue_max, self.queue.len());
     }
 
-    pub fn current(&self) -> Option<(&TwistAnimation, f32)> {
+    pub fn current(&self) -> Option<(&AnimationFromState, f32)> {
         Some((self.queue.front()?, self.progress))
     }
 }
 
 #[derive(Debug, Clone)]
-pub struct TwistAnimation {
-    /// Puzzle state before the twist.
-    pub state: PuzzleState,
-    /// Set of pieces affected by the twist.
-    pub grip: PieceMask,
-    /// Initial transform of the gripped pieces (identity, unless the move was
-    /// inputted using a mouse drag).
-    pub initial_transform: pga::Motor,
-    /// Final transform for the the gripped pieces.
-    pub final_transform: pga::Motor,
+pub struct AnimationFromState {
+    /// Puzzle state before the animation.
+    pub state: HypershapePuzzleState,
+    /// Animation to apply to the state.
+    pub anim: BoxDynPuzzleAnimation,
 }