Struct GameInstance 

pub struct GameInstance {
    pub fixed_delta_time: f32,
    pub unfocused_fixed_delta_time_scale: f32,
    pub color_shader: &'static str,
    pub image_shader: &'static str,
    pub text_shader: &'static str,
    pub input_maintain_on_fixed_step: bool,
    /* private fields */
}

Fields

fixed_delta_time: f32

unfocused_fixed_delta_time_scale: f32

color_shader: &'static str

image_shader: &'static str

text_shader: &'static str

input_maintain_on_fixed_step: bool

Implementations

impl GameInstance

pub fn new(state: impl GameState + 'static) -> Self

Examples found in repository

examples/spine.rs (line 26)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(Preloader).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("Spine 2D")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

examples/scripting.rs (line 40)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(Preloader).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("Scripting")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

examples/coroutines.rs (line 29)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(Preloader).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("Coroutines")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

examples/gc.rs (line 32)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(Preloader).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("GC")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

examples/path.rs (line 23)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(State::default()).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("Path")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

examples/gltf.rs (line 39)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(Preloader).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("GLTF")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

Additional examples can be found in:

• examples/hello_world.rs
• examples/ldtk.rs
• examples/async_life_cycle.rs
• examples/gltf_step_anim.rs
• examples/pcg_island.rs
• examples/ggpo.rs
• examples/rollback.rs
• examples/client_server.rs
• examples/prediction_reconciliation.rs
• examples/editable.rs

pub fn with_editor(self, editor: Editor) -> Self

Examples found in repository

examples/editable.rs (lines 39-43)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(
        GameInstance::new(Preloader)
            .setup_assets(|assets| {
                *assets = make_directory_database("./resources/").unwrap();
            })
            .setup(|instance| {
                #[cfg(feature = "editor")]
                {
                    use quaso::editor::ui::editor_game_edit;
                    instance.with_editor(
                        Editor::default()
                            .with_gui_drawer(editor_game_edit)
                            .show_editor_while_running(false),
                    )
                }
                #[cfg(not(feature = "editor"))]
                instance
            }),
    )
    .title("Editable")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

pub fn with_fixed_time_step(self, value: f32) -> Self

pub fn with_fps(self, frames_per_second: usize) -> Self

pub fn with_unfocused_fixed_time_step_scale(self, value: f32) -> Self

Examples found in repository

examples/pcg_island.rs (line 50)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(
        GameInstance::new(State::default())
            .with_unfocused_fixed_time_step_scale(15.0)
            .setup_assets(|assets| {
                *assets = make_directory_database("./resources/").unwrap();
            }),
    )
    .title("Procedural Content Generator - Island")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

pub fn with_color_shader(self, name: &'static str) -> Self

pub fn with_image_shader(self, name: &'static str) -> Self

pub fn with_text_shader(self, name: &'static str) -> Self

pub fn with_input_maintain_on_fixed_step(self, value: bool) -> Self

pub fn with_subsystem(self, subsystem: impl GameSubsystem + 'static) -> Self

pub fn with_globals<T: 'static>(self, value: T) -> Self

pub fn with_jobs(self, jobs: Jobs) -> Self

pub fn with_jobs_unnamed_worker(self, iteration_timeout: Duration) -> Self

pub fn with_jobs_named_worker( self, iteration_timeout: Duration, name: impl ToString, ) -> Self

pub fn with_network(self, network: GameNetwork) -> Self

pub fn with_gamepads(self) -> Self

pub fn with_gamepads_custom(self, gamepads: Gilrs) -> Self

pub fn setup_assets(self, f: impl FnOnce(&mut AssetDatabase)) -> Self

Examples found in repository

examples/spine.rs (lines 26-28)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(Preloader).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("Spine 2D")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

examples/scripting.rs (lines 40-42)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(Preloader).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("Scripting")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

examples/coroutines.rs (lines 29-31)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(Preloader).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("Coroutines")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

examples/gc.rs (lines 32-34)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(Preloader).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("GC")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

examples/path.rs (lines 23-25)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(State::default()).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("Path")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

examples/gltf.rs (lines 39-41)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(GameInstance::new(Preloader).setup_assets(|assets| {
        *assets = make_directory_database("./resources/").unwrap();
    }))
    .title("GLTF")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

Additional examples can be found in:

• examples/hello_world.rs
• examples/ldtk.rs
• examples/async_life_cycle.rs
• examples/gltf_step_anim.rs
• examples/pcg_island.rs
• examples/ggpo.rs
• examples/rollback.rs
• examples/client_server.rs
• examples/prediction_reconciliation.rs
• examples/editable.rs

pub fn setup(self, f: impl FnOnce(Self) -> Self) -> Self

Examples found in repository

examples/editable.rs (lines 35-47)

fn main() -> Result<(), Box<dyn Error>> {
    GameLauncher::new(
        GameInstance::new(Preloader)
            .setup_assets(|assets| {
                *assets = make_directory_database("./resources/").unwrap();
            })
            .setup(|instance| {
                #[cfg(feature = "editor")]
                {
                    use quaso::editor::ui::editor_game_edit;
                    instance.with_editor(
                        Editor::default()
                            .with_gui_drawer(editor_game_edit)
                            .show_editor_while_running(false),
                    )
                }
                #[cfg(not(feature = "editor"))]
                instance
            }),
    )
    .title("Editable")
    .config(Config::load_from_file("./resources/GameConfig.toml")?)
    .run();
    Ok(())
}

pub fn fps(&self) -> usize

pub fn set_fps(&mut self, frames_per_second: usize)

pub fn process_frame(&mut self, graphics: &mut Graphics<Vertex>)

pub fn process_event(&mut self, event: &Event<'_, ()>) -> bool

Trait Implementations

impl AppState<Vertex> for GameInstance

fn on_init(&mut self, _graphics: &mut Graphics<Vertex>, _: &mut AppControl)

fn on_redraw(&mut self, graphics: &mut Graphics<Vertex>, _: &mut AppControl)

fn on_event(&mut self, event: Event<'_, ()>, _: &mut Window) -> bool

impl Default for GameInstance

fn default() -> Self

Returns the “default value” for a type.