FyroxEngine/Fyrox
1
0
Fork 0
mirror of https://github.com/FyroxEngine/Fyrox.git synced 2026-10-12 02:02:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

fixed examples

Browse Source
This commit is contained in:
Dmitry
2023-08-07 21:08:36 +03:00
parent f2ce4fb872
commit 2b6f528af7
18 changed files with 304 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/2d.rs
+16 -17
View File
@@ -13,7 +13,7 @@ use fyrox::{
pool::Handle,
},
engine::{executor::Executor, GraphicsContext, GraphicsContextParams},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::ControlFlow,
gui::{
message::MessageDirection,
@@ -33,6 +33,7 @@ use fyrox::{
},
window::WindowAttributes,
};
use winit::keyboard::KeyCode;
struct SceneLoader {
scene: Scene,
@@ -175,26 +176,24 @@ impl Plugin for Game {
_control_flow: &mut ControlFlow,
) {
if let Event::WindowEvent {
event: WindowEvent::KeyboardInput { input, .. },
event: WindowEvent::KeyboardInput { event: input, .. },
..
} = event
{
if let Some(key_code) = input.virtual_keycode {
match key_code {
VirtualKeyCode::W => {
self.input_controller.move_forward = input.state == ElementState::Pressed
}
VirtualKeyCode::S => {
self.input_controller.move_backward = input.state == ElementState::Pressed
}
VirtualKeyCode::A => {
self.input_controller.move_left = input.state == ElementState::Pressed
}
VirtualKeyCode::D => {
self.input_controller.move_right = input.state == ElementState::Pressed
}
_ => (),
match input.physical_key {
KeyCode::KeyW => {
self.input_controller.move_forward = input.state == ElementState::Pressed
}
KeyCode::KeyS => {
self.input_controller.move_backward = input.state == ElementState::Pressed
}
KeyCode::KeyA => {
self.input_controller.move_left = input.state == ElementState::Pressed
}
KeyCode::KeyD => {
self.input_controller.move_right = input.state == ElementState::Pressed
}
_ => (),
}
}
}
examples/2d_scene.rs
+16 -18
View File
@@ -10,7 +10,7 @@ use fyrox::{
core::{algebra::Vector3, color::Color, futures::executor::block_on, pool::Handle},
engine::{executor::Executor, GraphicsContext, GraphicsContextParams},
event::Event,
event::{ElementState, VirtualKeyCode, WindowEvent},
event::{ElementState, WindowEvent},
event_loop::ControlFlow,
gui::{
message::MessageDirection,
@@ -27,6 +27,7 @@ use fyrox::{
},
window::WindowAttributes,
};
use winit::keyboard::KeyCode;
struct SceneLoader {
scene: Scene,
@@ -114,27 +115,24 @@ impl Plugin for Game {
_control_flow: &mut ControlFlow,
) {
if let Event::WindowEvent {
event: WindowEvent::KeyboardInput { input, .. },
event: WindowEvent::KeyboardInput { event: input, .. },
..
} = event
{
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
if let Some(key_code) = input.virtual_keycode {
match key_code {
VirtualKeyCode::W => {
self.input_controller.move_forward = input.state == ElementState::Pressed
}
VirtualKeyCode::S => {
self.input_controller.move_backward = input.state == ElementState::Pressed
}
VirtualKeyCode::A => {
self.input_controller.move_left = input.state == ElementState::Pressed
}
VirtualKeyCode::D => {
self.input_controller.move_right = input.state == ElementState::Pressed
}
_ => (),
match input.physical_key {
KeyCode::KeyW => {
self.input_controller.move_forward = input.state == ElementState::Pressed
}
KeyCode::KeyS => {
self.input_controller.move_backward = input.state == ElementState::Pressed
}
KeyCode::KeyA => {
self.input_controller.move_left = input.state == ElementState::Pressed
}
KeyCode::KeyD => {
self.input_controller.move_right = input.state == ElementState::Pressed
}
_ => (),
}
}
}
examples/3rd_person.rs
+23 -24
View File
@@ -26,6 +26,7 @@ pub mod shared;
use crate::shared::{create_ui, fix_shadows_distance, Game, GameScene};
use std::time::Instant;
use winit::keyboard::KeyCode;
use fyrox::{
core::{
@@ -33,7 +34,7 @@ use fyrox::{
log::{Log, MessageKind},
},
engine::GraphicsContext,
event::{Event, VirtualKeyCode, WindowEvent},
event::{Event, WindowEvent},
event_loop::ControlFlow,
gui::{
message::MessageDirection, progress_bar::ProgressBarMessage, text::TextMessage,
@@ -181,13 +182,13 @@ fn main() {
println!("{:?}", fyrox::core::profiler::print());
}
Event::WindowEvent { event, .. } => {
match event {
match &event {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::Resized(size) => {
// It is very important to handle Resized event from window, because
// renderer knows nothing about window size - it must be notified
// directly when window size has changed.
if let Err(e) = game.engine.set_frame_size(size.into()) {
if let Err(e) = game.engine.set_frame_size((*size).into()) {
Log::writeln(
MessageKind::Error,
format!("Unable to set frame size: {:?}", e),
@@ -215,29 +216,27 @@ fn main() {
));
}
}
WindowEvent::KeyboardInput { input, .. } => {
if let Some(code) = input.virtual_keycode {
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
if let Some(game_scene) = game.game_scene.as_mut() {
game_scene.player.handle_key_event(&input, fixed_timestep);
}
WindowEvent::KeyboardInput { event: input, .. } => {
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
if let Some(game_scene) = game.game_scene.as_mut() {
game_scene.player.handle_key_event(&input, fixed_timestep);
}
let settings = match code {
VirtualKeyCode::Key1 => Some(QualitySettings::ultra()),
VirtualKeyCode::Key2 => Some(QualitySettings::high()),
VirtualKeyCode::Key3 => Some(QualitySettings::medium()),
VirtualKeyCode::Key4 => Some(QualitySettings::low()),
_ => None,
};
let settings = match input.physical_key {
KeyCode::Digit1 => Some(QualitySettings::ultra()),
KeyCode::Digit2 => Some(QualitySettings::high()),
KeyCode::Digit3 => Some(QualitySettings::medium()),
KeyCode::Digit4 => Some(QualitySettings::low()),
_ => None,
};
if let Some(settings) = settings {
if let GraphicsContext::Initialized(ref mut ctx) =
game.engine.graphics_context
{
ctx.renderer
.set_quality_settings(&fix_shadows_distance(settings))
.unwrap();
}
if let Some(settings) = settings {
if let GraphicsContext::Initialized(ref mut ctx) =
game.engine.graphics_context
{
ctx.renderer
.set_quality_settings(&fix_shadows_distance(settings))
.unwrap();
}
}
}
examples/async.rs
+10 -12
View File
@@ -17,7 +17,7 @@ use fyrox::{
pool::Handle,
},
engine::{executor::Executor, GraphicsContext, GraphicsContextParams},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::ControlFlow,
gui::{
grid::{Column, GridBuilder, Row},
@@ -32,6 +32,7 @@ use fyrox::{
window::WindowAttributes,
};
use std::sync::{Arc, Mutex};
use winit::keyboard::KeyCode;
use crate::shared::create_camera;
@@ -327,21 +328,18 @@ impl Plugin for Game {
_control_flow: &mut ControlFlow,
) {
if let Event::WindowEvent {
event: WindowEvent::KeyboardInput { input, .. },
event: WindowEvent::KeyboardInput { event: input, .. },
..
} = event
{
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
if let Some(key_code) = input.virtual_keycode {
match key_code {
VirtualKeyCode::A => {
self.input_controller.rotate_left = input.state == ElementState::Pressed
}
VirtualKeyCode::D => {
self.input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
match input.physical_key {
KeyCode::KeyA => {
self.input_controller.rotate_left = input.state == ElementState::Pressed
}
KeyCode::KeyD => {
self.input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
}
}
}
examples/blend_shape.rs
+10 -11
View File
@@ -11,7 +11,7 @@ use fyrox::{
pool::Handle,
},
engine::{executor::Executor, GraphicsContext, GraphicsContextParams},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::ControlFlow,
gui::{
grid::{Column, GridBuilder, Row},
@@ -34,6 +34,7 @@ use fyrox::{
window::WindowAttributes,
};
use std::collections::BTreeSet;
use winit::keyboard::KeyCode;
struct GameSceneLoader {
scene: Scene,
@@ -224,20 +225,18 @@ impl Plugin for Game {
_control_flow: &mut ControlFlow,
) {
if let Event::WindowEvent {
event: WindowEvent::KeyboardInput { input, .. },
event: WindowEvent::KeyboardInput { event: input, .. },
..
} = event
{
if let Some(key_code) = input.virtual_keycode {
match key_code {
VirtualKeyCode::A => {
self.input_controller.rotate_left = input.state == ElementState::Pressed
}
VirtualKeyCode::D => {
self.input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
match input.physical_key {
KeyCode::KeyA => {
self.input_controller.rotate_left = input.state == ElementState::Pressed
}
KeyCode::KeyD => {
self.input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
}
}
}
examples/inspector.rs
+10 -11
View File
@@ -14,7 +14,7 @@ use fyrox::{
engine::{
Engine, EngineInitParams, GraphicsContext, GraphicsContextParams, SerializationContext,
},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::{ControlFlow, EventLoop},
gui::{
inspector::{
@@ -27,12 +27,13 @@ use fyrox::{
window::{WindowBuilder, WindowTitle},
UiNode,
},
keyboard::KeyCode,
resource::model::{Model, ModelResourceExtension},
scene::{node::Node, Scene},
utils::translate_event,
window::WindowAttributes,
};
use std::{rc::Rc, sync::Arc, time::Instant};
use winit::window::WindowAttributes;
struct Interface {
debug_text: Handle<UiNode>,
@@ -248,26 +249,24 @@ fn main() {
engine.render().unwrap();
}
Event::WindowEvent { event, .. } => {
match event {
match &event {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::Resized(size) => {
// It is very important to handle Resized event from window, because
// renderer knows nothing about window size - it must be notified
// directly when window size has changed.
if let Err(e) = engine.set_frame_size(size.into()) {
if let Err(e) = engine.set_frame_size((*size).into()) {
Log::writeln(
MessageKind::Error,
format!("Unable to set frame size: {:?}", e),
);
}
}
WindowEvent::KeyboardInput { input, .. } => {
if let Some(key_code) = input.virtual_keycode {
if input.state == ElementState::Pressed
&& key_code == VirtualKeyCode::Escape
{
*control_flow = ControlFlow::Exit;
}
WindowEvent::KeyboardInput { event: input, .. } => {
if input.state == ElementState::Pressed
&& input.physical_key == KeyCode::Escape
{
*control_flow = ControlFlow::Exit;
}
}
_ => (),
examples/instancing.rs
+10 -11
View File
@@ -19,7 +19,7 @@ use fyrox::{
sstorage::ImmutableString,
},
engine::{executor::Executor, GraphicsContext, GraphicsContextParams},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::ControlFlow,
gui::{
message::MessageDirection,
@@ -45,6 +45,7 @@ use fyrox::{
},
window::WindowAttributes,
};
use winit::keyboard::KeyCode;
struct SceneLoader {
scene: Scene,
@@ -237,20 +238,18 @@ impl Plugin for Game {
_control_flow: &mut ControlFlow,
) {
if let Event::WindowEvent {
event: WindowEvent::KeyboardInput { input, .. },
event: WindowEvent::KeyboardInput { event: input, .. },
..
} = event
{
if let Some(key_code) = input.virtual_keycode {
match key_code {
VirtualKeyCode::A => {
self.input_controller.rotate_left = input.state == ElementState::Pressed
}
VirtualKeyCode::D => {
self.input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
match input.physical_key {
KeyCode::KeyA => {
self.input_controller.rotate_left = input.state == ElementState::Pressed
}
KeyCode::KeyD => {
self.input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
}
}
}
examples/lightmap.rs
+12 -18
View File
@@ -21,7 +21,7 @@ use fyrox::{
engine::{
Engine, EngineInitParams, GraphicsContext, GraphicsContextParams, SerializationContext,
},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::{ControlFlow, EventLoop},
gui::{
button::{ButtonBuilder, ButtonMessage},
@@ -47,6 +47,7 @@ use std::{
sync::{Arc, Mutex},
time::Instant,
};
use winit::keyboard::KeyCode;
const LIGHTMAP_SCENE_PATH: &str = "examples/data/lightmap_scene.rgs";
@@ -550,13 +551,13 @@ fn main() {
engine.render().unwrap();
}
Event::WindowEvent { event, .. } => {
match event {
match &event {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::Resized(size) => {
// It is very important to handle Resized event from window, because
// renderer knows nothing about window size - it must be notified
// directly when window size has changed.
if let Err(e) = engine.set_frame_size(size.into()) {
if let Err(e) = engine.set_frame_size((*size).into()) {
Log::writeln(
MessageKind::Error,
format!("Unable to set frame size: {:?}", e),
@@ -579,22 +580,15 @@ fn main() {
));
}
}
WindowEvent::KeyboardInput { input, .. } => {
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
if let Some(key_code) = input.virtual_keycode {
match key_code {
VirtualKeyCode::A => {
input_controller.rotate_left =
input.state == ElementState::Pressed
}
VirtualKeyCode::D => {
input_controller.rotate_right =
input.state == ElementState::Pressed
}
_ => (),
}
WindowEvent::KeyboardInput { event: input, .. } => match input.physical_key {
KeyCode::KeyA => {
input_controller.rotate_left = input.state == ElementState::Pressed
}
}
KeyCode::KeyD => {
input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
},
_ => (),
}
examples/lod.rs
+32 -30
View File
@@ -20,7 +20,7 @@ use fyrox::{
engine::{
Engine, EngineInitParams, GraphicsContext, GraphicsContextParams, SerializationContext,
},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::{ControlFlow, EventLoop},
gui::{
message::MessageDirection,
@@ -28,6 +28,7 @@ use fyrox::{
widget::WidgetBuilder,
BuildContext, UiNode,
},
keyboard::KeyCode,
resource::model::{Model, ModelResourceExtension},
scene::{
base::{LevelOfDetail, LodControlledObject, LodGroup},
@@ -35,9 +36,9 @@ use fyrox::{
Scene,
},
utils::translate_event,
window::WindowAttributes,
};
use std::time::Instant;
use winit::window::WindowAttributes;
fn create_ui(ctx: &mut BuildContext) -> Handle<UiNode> {
TextBuilder::new(WidgetBuilder::new()).build(ctx)
@@ -207,8 +208,6 @@ fn main() {
previous = Instant::now();
lag += elapsed.as_secs_f32();
while lag >= fixed_timestep {
// ************************
// Put your game logic here.
// ************************
@@ -232,16 +231,22 @@ fn main() {
scene.graph[model_handle]
.local_transform_mut()
.set_rotation(UnitQuaternion::from_axis_angle(&Vector3::y_axis(), model_angle));
.set_rotation(UnitQuaternion::from_axis_angle(
&Vector3::y_axis(),
model_angle,
));
scene.graph[camera]
.local_transform_mut()
.set_position(Vector3::new(0.0, 1.5, -distance));
if let GraphicsContext::Initialized(ref ctx) =engine.graphics_context {
if let GraphicsContext::Initialized(ref ctx) = engine.graphics_context {
let fps = ctx.renderer.get_statistics().frames_per_second;
let text = format!(
"Example 08 - Level of Detail\nUse [A][D] keys to rotate model, [W][S] to zoom in/out.\nFPS: {}\nTriangles rendered: {}",
"Example 08 - Level of Detail\n\
Use [A][D] keys to rotate model, \
[W][S] to zoom in/out.\nFPS: {}\n\
Triangles rendered: {}",
fps,
ctx.renderer.get_statistics().geometry.triangles_rendered
);
@@ -284,37 +289,34 @@ fn main() {
engine.render().unwrap();
}
Event::WindowEvent { event, .. } => {
match event {
match &event {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::Resized(size) => {
// It is very important to handle Resized event from window, because
// renderer knows nothing about window size - it must be notified
// directly when window size has changed.
if let Err(e) = engine.set_frame_size(size.into()) {
Log::writeln(MessageKind::Error, format!("Unable to set frame size: {:?}", e));
if let Err(e) = engine.set_frame_size((*size).into()) {
Log::writeln(
MessageKind::Error,
format!("Unable to set frame size: {:?}", e),
);
}
}
WindowEvent::KeyboardInput { input, .. } => {
if let Some(key_code) = input.virtual_keycode {
match key_code {
VirtualKeyCode::A => {
input_controller.rotate_left =
input.state == ElementState::Pressed
}
VirtualKeyCode::D => {
input_controller.rotate_right =
input.state == ElementState::Pressed
}
VirtualKeyCode::W => {
input_controller.forward = input.state == ElementState::Pressed
}
VirtualKeyCode::S => {
input_controller.backward = input.state == ElementState::Pressed
}
_ => (),
}
WindowEvent::KeyboardInput { event: input, .. } => match input.physical_key {
KeyCode::KeyA => {
input_controller.rotate_left = input.state == ElementState::Pressed
}
}
KeyCode::KeyD => {
input_controller.rotate_right = input.state == ElementState::Pressed
}
KeyCode::KeyW => {
input_controller.forward = input.state == ElementState::Pressed
}
KeyCode::KeyS => {
input_controller.backward = input.state == ElementState::Pressed
}
_ => (),
},
_ => (),
}
examples/navmesh.rs
+13 -21
View File
@@ -7,7 +7,6 @@
pub mod shared;
use crate::shared::create_camera;
use fyrox::resource::model::{Model, ModelResourceExtension};
use fyrox::{
asset::manager::ResourceManager,
core::{
@@ -20,7 +19,7 @@ use fyrox::{
},
dpi::LogicalPosition,
engine::{executor::Executor, GraphicsContext, GraphicsContextParams},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::ControlFlow,
gui::{
message::MessageDirection,
@@ -28,16 +27,16 @@ use fyrox::{
widget::WidgetBuilder,
BuildContext, UiNode,
},
material::SharedMaterial,
material::{Material, PropertyValue},
keyboard::KeyCode,
material::{Material, PropertyValue, SharedMaterial},
plugin::{Plugin, PluginConstructor, PluginContext},
scene::mesh::surface::SurfaceSharedData,
resource::model::{Model, ModelResourceExtension},
scene::{
base::BaseBuilder,
debug::Line,
graph::physics::{Intersection, RayCastOptions},
mesh::{
surface::{SurfaceBuilder, SurfaceData},
surface::{SurfaceBuilder, SurfaceData, SurfaceSharedData},
MeshBuilder,
},
node::Node,
@@ -239,22 +238,15 @@ impl Plugin for Game {
) {
if let Event::WindowEvent { event, .. } = event {
match event {
WindowEvent::KeyboardInput { input, .. } => {
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
if let Some(key_code) = input.virtual_keycode {
match key_code {
VirtualKeyCode::A => {
self.input_controller.rotate_left =
input.state == ElementState::Pressed
}
VirtualKeyCode::D => {
self.input_controller.rotate_right =
input.state == ElementState::Pressed
}
_ => (),
}
WindowEvent::KeyboardInput { event: input, .. } => match input.physical_key {
KeyCode::KeyA => {
self.input_controller.rotate_left = input.state == ElementState::Pressed
}
}
KeyCode::KeyD => {
self.input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
},
WindowEvent::CursorMoved { position, .. } => {
if let GraphicsContext::Initialized(ref graphics_context) =
context.graphics_context
examples/save_load.rs
+65 -55
View File
@@ -26,18 +26,18 @@ use fyrox::{
visitor::{Visit, VisitResult, Visitor},
},
engine::GraphicsContext,
event::{Event, VirtualKeyCode, WindowEvent},
event::{Event, WindowEvent},
event_loop::ControlFlow,
gui::{
message::MessageDirection, progress_bar::ProgressBarMessage, text::TextMessage,
widget::WidgetMessage,
},
keyboard::KeyCode,
renderer::QualitySettings,
scene::SceneLoader,
utils::translate_event,
};
use std::path::Path;
use std::time::Instant;
use std::{path::Path, time::Instant};
// Start implementing Visit trait for simple types which are used by more complex.
// At first implement trait for LocomotionMachine.
@@ -171,7 +171,6 @@ fn main() {
previous = Instant::now();
lag += elapsed.as_secs_f32();
while lag >= fixed_timestep {
// ************************
// Put your game logic here.
// ************************
@@ -236,7 +235,9 @@ fn main() {
if let GraphicsContext::Initialized(ref ctx) = game.engine.graphics_context {
let fps = ctx.renderer.get_statistics().frames_per_second;
let debug_text = format!(
"Example 06 - Save/load\n[W][S][A][D] - walk, [SPACE] - jump.\nFPS: {}\nUse [1][2][3][4] to select graphics quality.\nUse F5 to save game, F9 to load.",
"Example 06 - Save/load\n[W][S][A][D] - walk, \
[SPACE] - jump.\nFPS: {}\nUse [1][2][3][4] to select \
graphics quality.\nUse F5 to save game, F9 to load.",
fps
);
game.engine.user_interface.send_message(TextMessage::text(
@@ -257,7 +258,8 @@ fn main() {
// ************************
}
game.engine.update(fixed_timestep, control_flow, &mut lag, Default::default());
game.engine
.update(fixed_timestep, control_flow, &mut lag, Default::default());
lag -= fixed_timestep;
}
@@ -268,7 +270,9 @@ fn main() {
}
}
Event::Resumed => {
game.engine.initialize_graphics_context(window_target).unwrap();
game.engine
.initialize_graphics_context(window_target)
.unwrap();
}
Event::Suspended => {
game.engine.destroy_graphics_context().unwrap();
@@ -281,67 +285,71 @@ fn main() {
println!("{:?}", fyrox::core::profiler::print());
}
Event::WindowEvent { event, .. } => {
match event {
match &event {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::Resized(size) => {
// It is very important to handle Resized event from window, because
// renderer knows nothing about window size - it must be notified
// directly when window size has changed.
if let Err(e) = game.engine.set_frame_size(size.into()) {
Log::writeln(MessageKind::Error, format!("Unable to set frame size: {:?}", e));
if let Err(e) = game.engine.set_frame_size((*size).into()) {
Log::writeln(
MessageKind::Error,
format!("Unable to set frame size: {:?}", e),
);
}
// Root UI node should be resized too, otherwise progress bar will stay
// in wrong position after resize.
if let GraphicsContext::Initialized(ref ctx) = game.engine.graphics_context {
if let GraphicsContext::Initialized(ref ctx) = game.engine.graphics_context
{
let size = size.to_logical(ctx.window.scale_factor());
game.engine.user_interface.send_message(WidgetMessage::width(
interface.root,
MessageDirection::ToWidget,
size.width,
));
game.engine.user_interface.send_message(WidgetMessage::height(
interface.root,
MessageDirection::ToWidget,
size.height,
));
game.engine
.user_interface
.send_message(WidgetMessage::width(
interface.root,
MessageDirection::ToWidget,
size.width,
));
game.engine
.user_interface
.send_message(WidgetMessage::height(
interface.root,
MessageDirection::ToWidget,
size.height,
));
}
}
WindowEvent::KeyboardInput { input, .. } => {
if let Some(code) = input.virtual_keycode {
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
if let Some(game_scene) = game.game_scene.as_mut() {
game_scene.player.handle_key_event(&input, fixed_timestep);
}
WindowEvent::KeyboardInput { event: input, .. } => {
if let Some(game_scene) = game.game_scene.as_mut() {
game_scene.player.handle_key_event(&input, fixed_timestep);
}
let settings = match code {
VirtualKeyCode::Key1 => Some(QualitySettings::ultra()),
VirtualKeyCode::Key2 => Some(QualitySettings::high()),
VirtualKeyCode::Key3 => Some(QualitySettings::medium()),
VirtualKeyCode::Key4 => Some(QualitySettings::low()),
_ => None
let settings = match input.physical_key {
KeyCode::Digit1 => Some(QualitySettings::ultra()),
KeyCode::Digit2 => Some(QualitySettings::high()),
KeyCode::Digit3 => Some(QualitySettings::medium()),
KeyCode::Digit4 => Some(QualitySettings::low()),
_ => None,
};
if let Some(settings) = settings {
if let GraphicsContext::Initialized(ref mut ctx) =
game.engine.graphics_context
{
ctx.renderer
.set_quality_settings(&fix_shadows_distance(settings))
.unwrap();
}
}
// Prevent saving/loading while example is starting.
if game.game_scene.is_some() {
// Save/load bound to classic F5 and F9 keys.
match input.physical_key {
KeyCode::F5 => save(&mut game),
KeyCode::F9 => block_on(load(&mut game)),
_ => (),
};
if let Some(settings) = settings {
if let GraphicsContext::Initialized(ref mut ctx) = game.engine.graphics_context {
ctx
.renderer
.set_quality_settings(&fix_shadows_distance(settings))
.unwrap();
}
}
// Prevent saving/loading while example is starting.
if game.game_scene.is_some() {
// Save/load bound to classic F5 and F9 keys.
match code {
VirtualKeyCode::F5 => save(&mut game),
VirtualKeyCode::F9 =>
block_on(load(&mut game))
,
_ => ()
};
}
}
}
_ => (),
@@ -356,7 +364,9 @@ fn main() {
}
Event::DeviceEvent { event, .. } => {
if let Some(game_scene) = game.game_scene.as_mut() {
game_scene.player.handle_device_event(&event, fixed_timestep);
game_scene
.player
.handle_device_event(&event, fixed_timestep);
}
}
_ => *control_flow = ControlFlow::Poll,
examples/scene.rs
+13 -19
View File
@@ -20,7 +20,7 @@ use fyrox::{
engine::{
Engine, EngineInitParams, GraphicsContext, GraphicsContextParams, SerializationContext,
},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::{ControlFlow, EventLoop},
gui::{
message::MessageDirection,
@@ -28,12 +28,13 @@ use fyrox::{
widget::WidgetBuilder,
BuildContext, UiNode,
},
keyboard::KeyCode,
resource::model::{Model, ModelResourceExtension},
scene::{base::BaseBuilder, node::Node, pivot::PivotBuilder, Scene},
utils::translate_event,
window::WindowAttributes,
};
use std::{sync::Arc, time::Instant};
use winit::window::WindowAttributes;
fn create_ui(ctx: &mut BuildContext) -> Handle<UiNode> {
TextBuilder::new(WidgetBuilder::new()).build(ctx)
@@ -202,35 +203,28 @@ fn main() {
engine.render().unwrap();
}
Event::WindowEvent { event, .. } => {
match event {
match &event {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::Resized(size) => {
// It is very important to handle Resized event from window, because
// renderer knows nothing about window size - it must be notified
// directly when window size has changed.
if let Err(e) = engine.set_frame_size(size.into()) {
if let Err(e) = engine.set_frame_size((*size).into()) {
Log::writeln(
MessageKind::Error,
format!("Unable to set frame size: {:?}", e),
);
}
}
WindowEvent::KeyboardInput { input, .. } => {
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
if let Some(key_code) = input.virtual_keycode {
match key_code {
VirtualKeyCode::A => {
input_controller.rotate_left =
input.state == ElementState::Pressed
}
VirtualKeyCode::D => {
input_controller.rotate_right =
input.state == ElementState::Pressed
}
_ => (),
}
WindowEvent::KeyboardInput { event: input, .. } => match input.physical_key {
KeyCode::KeyA => {
input_controller.rotate_left = input.state == ElementState::Pressed
}
}
KeyCode::KeyD => {
input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
},
_ => (),
}
examples/shared/mod.rs
+10 -17
View File
@@ -21,7 +21,7 @@ use fyrox::{
uuid::{uuid, Uuid},
},
engine::{Engine, EngineInitParams, SerializationContext},
event::{DeviceEvent, ElementState, VirtualKeyCode},
event::{DeviceEvent, ElementState},
event_loop::EventLoop,
gui::{
formatted_text::WrapMode,
@@ -32,6 +32,7 @@ use fyrox::{
HorizontalAlignment, Thickness, VerticalAlignment,
},
gui::{BuildContext, UiNode},
keyboard::KeyCode,
renderer::QualitySettings,
resource::texture::TextureWrapMode,
scene::{
@@ -758,22 +759,14 @@ impl Player {
}
}
pub fn handle_key_event(&mut self, key: &fyrox::event::KeyboardInput, _dt: f32) {
if let Some(key_code) = key.virtual_keycode {
match key_code {
VirtualKeyCode::W => {
self.controller.walk_forward = key.state == ElementState::Pressed
}
VirtualKeyCode::S => {
self.controller.walk_backward = key.state == ElementState::Pressed
}
VirtualKeyCode::A => self.controller.walk_left = key.state == ElementState::Pressed,
VirtualKeyCode::D => {
self.controller.walk_right = key.state == ElementState::Pressed
}
VirtualKeyCode::Space => self.controller.jump = key.state == ElementState::Pressed,
_ => (),
}
pub fn handle_key_event(&mut self, key: &fyrox::event::KeyEvent, _dt: f32) {
match key.physical_key {
KeyCode::KeyW => self.controller.walk_forward = key.state == ElementState::Pressed,
KeyCode::KeyS => self.controller.walk_backward = key.state == ElementState::Pressed,
KeyCode::KeyA => self.controller.walk_left = key.state == ElementState::Pressed,
KeyCode::KeyD => self.controller.walk_right = key.state == ElementState::Pressed,
KeyCode::Space => self.controller.jump = key.state == ElementState::Pressed,
_ => (),
}
}
}
examples/simple.rs
+10 -11
View File
@@ -18,7 +18,7 @@ use fyrox::{
sstorage::ImmutableString,
},
engine::{executor::Executor, GraphicsContext, GraphicsContextParams},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::ControlFlow,
gui::{
message::MessageDirection,
@@ -41,6 +41,7 @@ use fyrox::{
},
window::WindowAttributes,
};
use winit::keyboard::KeyCode;
struct GameSceneLoader {
scene: Scene,
@@ -193,20 +194,18 @@ impl Plugin for Game {
_control_flow: &mut ControlFlow,
) {
if let Event::WindowEvent {
event: WindowEvent::KeyboardInput { input, .. },
event: WindowEvent::KeyboardInput { event: input, .. },
..
} = event
{
if let Some(key_code) = input.virtual_keycode {
match key_code {
VirtualKeyCode::A => {
self.input_controller.rotate_left = input.state == ElementState::Pressed
}
VirtualKeyCode::D => {
self.input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
match input.physical_key {
KeyCode::KeyA => {
self.input_controller.rotate_left = input.state == ElementState::Pressed
}
KeyCode::KeyD => {
self.input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
}
}
}
examples/sound.rs
+23 -24
View File
@@ -17,7 +17,7 @@ use fyrox::{
uuid::{uuid, Uuid},
},
engine::GraphicsContext,
event::{Event, VirtualKeyCode, WindowEvent},
event::{Event, WindowEvent},
event_loop::ControlFlow,
gui::{
message::MessageDirection, progress_bar::ProgressBarMessage, text::TextMessage,
@@ -36,6 +36,7 @@ use fyrox::{
use fyrox_sound::buffer::SoundBuffer;
use fyrox_sound::bus::AudioBusGraph;
use std::time::Instant;
use winit::keyboard::KeyCode;
const FOOTSTEP_SIGNAL: Uuid = uuid!("3e536261-9edf-4436-bba0-11173e61c8e9");
@@ -282,13 +283,13 @@ fn main() {
println!("{:?}", fyrox::core::profiler::print());
}
Event::WindowEvent { event, .. } => {
match event {
match &event {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::Resized(size) => {
// It is very important to handle Resized event from window, because
// renderer knows nothing about window size - it must be notified
// directly when window size has changed.
if let Err(e) = game.engine.set_frame_size(size.into()) {
if let Err(e) = game.engine.set_frame_size((*size).into()) {
Log::writeln(
MessageKind::Error,
format!("Unable to set frame size: {:?}", e),
@@ -316,29 +317,27 @@ fn main() {
));
}
}
WindowEvent::KeyboardInput { input, .. } => {
if let Some(code) = input.virtual_keycode {
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
if let Some(game_scene) = game.game_scene.as_mut() {
game_scene.player.handle_key_event(&input, fixed_timestep);
}
WindowEvent::KeyboardInput { event: input, .. } => {
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
if let Some(game_scene) = game.game_scene.as_mut() {
game_scene.player.handle_key_event(&input, fixed_timestep);
}
let settings = match code {
VirtualKeyCode::Key1 => Some(QualitySettings::ultra()),
VirtualKeyCode::Key2 => Some(QualitySettings::high()),
VirtualKeyCode::Key3 => Some(QualitySettings::medium()),
VirtualKeyCode::Key4 => Some(QualitySettings::low()),
_ => None,
};
let settings = match input.physical_key {
KeyCode::Digit1 => Some(QualitySettings::ultra()),
KeyCode::Digit2 => Some(QualitySettings::high()),
KeyCode::Digit3 => Some(QualitySettings::medium()),
KeyCode::Digit4 => Some(QualitySettings::low()),
_ => None,
};
if let Some(settings) = settings {
if let GraphicsContext::Initialized(ref mut ctx) =
game.engine.graphics_context
{
ctx.renderer
.set_quality_settings(&fix_shadows_distance(settings))
.unwrap();
}
if let Some(settings) = settings {
if let GraphicsContext::Initialized(ref mut ctx) =
game.engine.graphics_context
{
ctx.renderer
.set_quality_settings(&fix_shadows_distance(settings))
.unwrap();
}
}
}
examples/terrain.rs
+10 -11
View File
@@ -16,7 +16,7 @@ use fyrox::{
TypeUuidProvider,
},
engine::{executor::Executor, GraphicsContext, GraphicsContextParams},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::ControlFlow,
gui::{
message::MessageDirection,
@@ -37,6 +37,7 @@ use fyrox::{
},
window::WindowAttributes,
};
use winit::keyboard::KeyCode;
struct SceneLoader {
scene: Scene,
@@ -223,21 +224,19 @@ impl Plugin for Game {
_control_flow: &mut ControlFlow,
) {
if let Event::WindowEvent {
event: WindowEvent::KeyboardInput { input, .. },
event: WindowEvent::KeyboardInput { event: input, .. },
..
} = event
{
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
if let Some(key_code) = input.virtual_keycode {
match key_code {
VirtualKeyCode::A => {
self.input_controller.rotate_left = input.state == ElementState::Pressed
}
VirtualKeyCode::D => {
self.input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
match input.physical_key {
KeyCode::KeyA => {
self.input_controller.rotate_left = input.state == ElementState::Pressed
}
KeyCode::KeyD => {
self.input_controller.rotate_right = input.state == ElementState::Pressed
}
_ => (),
}
}
}
examples/ui.rs
+9 -13
View File
@@ -20,7 +20,7 @@ use fyrox::{
engine::{
Engine, EngineInitParams, GraphicsContext, GraphicsContextParams, SerializationContext,
},
event::{ElementState, Event, VirtualKeyCode, WindowEvent},
event::{ElementState, Event, WindowEvent},
event_loop::{ControlFlow, EventLoop},
gui::{
border::BorderBuilder,
@@ -44,6 +44,7 @@ use fyrox::{
window::{Fullscreen, WindowAttributes},
};
use std::{sync::Arc, time::Instant};
use winit::keyboard::KeyCode;
const DEFAULT_MODEL_ROTATION: f32 = 180.0;
const DEFAULT_MODEL_SCALE: f32 = 0.05;
@@ -481,26 +482,24 @@ fn main() {
engine.render().unwrap();
}
Event::WindowEvent { event, .. } => {
match event {
match &event {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::Resized(size) => {
// It is very important to handle Resized event from window, because
// renderer knows nothing about window size - it must be notified
// directly when window size has changed.
if let Err(e) = engine.set_frame_size(size.into()) {
if let Err(e) = engine.set_frame_size((*size).into()) {
Log::writeln(
MessageKind::Error,
format!("Unable to set frame size: {:?}", e),
);
}
}
WindowEvent::KeyboardInput { input, .. } => {
if let Some(key_code) = input.virtual_keycode {
if input.state == ElementState::Pressed
&& key_code == VirtualKeyCode::Escape
{
*control_flow = ControlFlow::Exit;
}
WindowEvent::KeyboardInput { event: input, .. } => {
if input.state == ElementState::Pressed
&& input.physical_key == KeyCode::Escape
{
*control_flow = ControlFlow::Exit;
}
}
_ => (),
@@ -513,9 +512,6 @@ fn main() {
engine.user_interface.process_os_event(&os_event);
}
}
Event::DeviceEvent { .. } => {
// Handle key input events via `WindowEvent`, not via `DeviceEvent` (#32)
}
_ => *control_flow = ControlFlow::Poll,
}
});
fyrox-ui/src/lib.rs
+12 -2
View File
@@ -2490,6 +2490,7 @@ fn transform_size(transform_space_bounds: Vector2<f32>, matrix: &Matrix3<f32>) -
#[cfg(test)]
mod test {
use crate::message::{ButtonState, KeyCode};
use crate::{
border::BorderBuilder,
core::algebra::{Rotation2, UnitComplex, Vector2},
@@ -2564,14 +2565,23 @@ mod test {
);
// Do additional check - emulate key press of "A" and check if the focused text box has accepted it.
ui.process_os_event(&OsEvent::Character('A'));
ui.process_os_event(&OsEvent::KeyboardInput {
button: KeyCode::KeyA,
state: ButtonState::Pressed,
text: "A".to_string(),
});
let mut msg =
WidgetMessage::key_down(text_box, MessageDirection::FromWidget, KeyCode::KeyA);
msg.set_handled(true);
assert_eq!(ui.poll_message(), Some(msg));
assert_eq!(
ui.poll_message(),
Some(WidgetMessage::text(
text_box,
MessageDirection::FromWidget,
'A'
'A'.to_string()
))
);
assert_eq!(