Struct StepperClosures

pub struct StepperClosures<'a> { /* private fields */ }

Helper to create the whole code of a Stepper in method IStepper::initialize() while avoiding multiple fields.

Not really convincing with too many compromises. The privileged solution is the use of the derive macro crate::IStepper

See Demo b_stepper.rs::BStepper Non canonical structure

Examples:

stereokit_rust::test_init_sk!(); // !!!! Get a proper way to initialize sk !!!!
use stereokit_rust::{font::Font, framework::StepperClosures, material::Material,
                     maths::{Matrix, Quat, Vec3},mesh::Mesh, system::{Renderer, Text},
                     util::{Time, named_colors},};

pub struct BStepper {
    id: StepperId,
    sk_info: Option<Rc<RefCell<SkInfo>>>,
    pub text: String,
    closures: StepperClosures<'static>,
}

unsafe impl Send for BStepper {}

/// This code may be called in some threads, so no StereoKit code
impl Default for BStepper {
    fn default() -> Self {
        Self {
            id: "BStepper".to_string(),
            sk_info: None,
            text: "\nStepperClosures".to_owned(),
            closures: StepperClosures::new(),
        }
    }
}

/// All the code here run in the main thread
impl IStepper for BStepper {
    fn initialize(&mut self, id: StepperId, sk_info: Rc<RefCell<SkInfo>>) -> bool {
        self.id = id;
        self.sk_info = Some(sk_info);

        let mut transform = Matrix::t_r([0.0, 1.0, -0.5], [0.0, 180.0, 0.0]);
        let mut round_cube = Mesh::generate_rounded_cube(Vec3::ONE / 5.0, 0.005, Some(16));
        round_cube.id("round_cube BStepper");
        let text_style = Some(Text::make_style(Font::default(), 0.3, named_colors::GOLD));
        let text = self.text.clone();

        self.closures.set(
            move |token| {
                Renderer::add_mesh(token, &round_cube, Material::pbr(),
                                   transform, Some(named_colors::RED.into()), None);
                Text::add_at(token, &text, transform, text_style,
                             None, None, None, None, None, None);
                // (1) You cannot do that here: self.text = "youpi".into();
            },
            || Log::diag("Closing Stepper B !!!"),
        );
        true
    }

    fn step(&mut self, token: &MainThreadToken) {
        self.closures.step(token);
        // (2) Add here The code about fields that are shared with shutdown >>>
        {}
        //<<<
    }

    fn shutdown(&mut self) {
        self.closures.shutdown();
        // (3) Add here The code about fields that are shared with step >>>
        {}
        //<<<
    }
}

sk.send_event(StepperAction::add_default::<BStepper>("My_Basic_Stepper_ID"));

filename_scr = "screenshots/stepper_closures.jpeg";
test_screenshot!( // !!!! Get a proper main loop !!!!
    // No code here as we only use BStepper
);

Implementations

impl StepperClosures<'_>

pub fn new() -> Self

Same as default, but with a more explicit name

pub fn set<U: FnMut(&MainThreadToken) + 'static, S: FnMut() + 'static>( &mut self, on_step: U, on_shutdown: S, ) -> &mut Self

Set the stepper closures.

• on_step - The closure to call on each step.
• on_shutdown - The closure to call on shutdown.

pub fn step(&mut self, token: &MainThreadToken)

To call on each step.

• token - The main thread token.

pub fn shutdown(&mut self)

To call on shutdown.

Trait Implementations

impl Default for StepperClosures<'_>

fn default() -> Self

Same as new, but with a more explicit name