Function despero::math::radian::to_radian

source · 
pub fn to_radian(deg: f32) -> f32
Examples found in repository?
examples/pbr.rs (line 52)
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

fn create_scene(
    mut cmd: Write<CommandBuffer>,
    mut asset_manager: Write<AssetManager>,
){    
    let diffuse = asset_manager.create_texture("assets/pbr_test/diffuse.jpg", Filter::Linear);
    
    cmd.spawn(
        ModelBundle::builder()
            .mesh(Mesh::plane())
            .material(asset_manager.create_material(
                DefaultMat::builder()
                    .albedo(diffuse)
                    .metallic(0.0)
                    .roughness(0.5)
                    .build()
            ))
            .transform(Transform::from_rotation(UnitQuaternion::from_axis_angle(&Vector3::x_axis(), to_radian(-45.0))))
            .build()
    );
    
    cmd.spawn((
        Camera::builder()
            .is_active(true)
            .camera_type(CameraType::FirstPerson)
            .build(),
        Transform::from_translation(Vector3::new(0.0, 0.0, 3.0)),
        CameraConfiguration {
            limit: (-85.0, 85.0),
            ..Default::default()
        },
    ));
    
    cmd.spawn((
        DirectionalLight {
            direction: Vector3::new(-1., -1., 0.),
            illuminance: [0.5, 0.5, 0.5],
        },
    ));
    
    let sky_tex = asset_manager.create_texture("assets/StandardCubeMap.png", Filter::Linear);
    
    cmd.spawn(
        ModelBundle::builder()
            .mesh(Mesh::load_obj("assets/skybox.obj").swap_remove(0))
            .material(
                asset_manager.create_material(
                    DefaultMat::builder()
                        .albedo(sky_tex)
                        .build()
                )
            )
            .transform(Transform::default())
            .build()
    );
}

fn process_scene(
    camera_world: SubWorld<(&Camera, &mut CameraConfiguration, &mut Transform)>,
    gui_events: Read<EventHandler<GuiContext>>,
    time: Read<Time>,
){
    if let Some(ctx) = gui_events.read() {
        if let Some(current) = ctx.pointer_hover_pos() {
            for (_, (_, mut conf, mut t)) in &mut camera_world.query::<(&Camera, &mut CameraConfiguration, &mut Transform)>(){       
                let (delta_x, delta_y) = {
                    if conf.latest_pos == Point2::origin() {
                        (0.0, 0.0)
                    } else {
                        (current.x - conf.latest_pos.x, current.y - conf.latest_pos.y)
                    }
                };
                
                conf.latest_pos = Point2::new(current.x, current.y);
                
                let local_x = t.local_x();
                
                let (tx, ty) = (conf.target_x.clone(), conf.target_y.clone());
                
                conf.target_x += delta_y * 0.0005 * time.delta_time().as_millis() as f32;
                conf.target_y -= delta_x * 0.0005 * time.delta_time().as_millis() as f32;
                
                conf.target_x = conf.target_x.clamp(to_radian(conf.limit.0), to_radian(conf.limit.1));

                t.rotation *= 
                    UnitQuaternion::from_axis_angle(&local_x, conf.target_x - tx) * 
                    UnitQuaternion::from_axis_angle(&Vector3::y_axis(), conf.target_y - ty);
            }
        }
    }
}
More examples
Hide additional examples
examples/serde.rs (line 70)
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

fn gui_system(
    gui_events: Read<EventHandler<GuiContext>>,
    world: Read<World>,
    mut cmd: Write<CommandBuffer>,
    mut asset_manager: Write<AssetManager>,
    model_world: SubWorld<Without<&mut Transform, &Camera>>,
    scene_world: SubWorld<(&u32, &Transform)>,
){
    for (_, mut t) in &mut model_world.query::<Without<&mut Transform, &Camera>>(){
        t.rotation *= UnitQuaternion::from_axis_angle(&Unit::new_normalize(Vector3::new(1.0, 1.0, 1.0)), to_radian(1.0));
    }
    
    if let Some(ctx) = gui_events.read() {
        
        gui::SidePanel::left("my_panel").show(&ctx, |ui| {
            ui.label("World (de-)serialization test");
            
            let mut ws = WorldSaver::new();
            
            if ui.button("Save world").clicked() {
                match ws.save("assets/world.ron", &world) {
                    Ok(()) => info!("World saved!"),
                    Err(e) => error!("World not saved: {:?}", e),
                };
            }
            
            if ui.button("Load world").clicked() {
                cmd.write(move |world: &mut World| {
                    match ws.load("assets/world.ron", world) {
                        Ok(()) => info!("World loaded!"),
                        Err(e) => error!("World not loaded: {:?}", e),
                    }
                })
            }
            
            ui.separator();
            
            ui.label("Serializable scene structure:");
            
            if ui.button("Save scene to file").clicked() {
                let scene = Scene {
                    assets: AssetManager::default(),
                    entities: vec![
                        SerializableEntity {
                            components: vec![
                                Arc::new(16u32),
                                Arc::new(Transform::default())
                            ],
                        },
                    ],
                };
                
                scene.save("assets/my_scene.ron").expect("Cannot save the scene");
            }
            
            if ui.button("Load scene from file").clicked() {
                let scene = Scene::load("assets/my_scene.ron").expect("Cannot load the scene");
                
                cmd.spawn_scene(scene, &mut asset_manager);
            }
            
            ui.separator();
            
            for (_, (_, _)) in &mut scene_world.query::<(&u32, &Transform)>(){
                ui.label("Scene successfully loaded!");
            }
            
        });
    }
}