Function macroquad::camera::set_default_camera
source · pub fn set_default_camera()
Expand description
Reset default 2D camera mode.
Examples found in repository?
examples/camera.rs (line 20)
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
async fn main() {
loop {
clear_background(LIGHTGRAY);
// Render some primitives in camera space
set_camera(&Camera2D {
zoom: vec2(1., screen_width() / screen_height()),
..Default::default()
});
draw_line(-0.4, 0.4, -0.8, 0.9, 0.05, BLUE);
draw_rectangle(-0.3, 0.3, 0.2, 0.2, GREEN);
draw_circle(0., 0., 0.1, YELLOW);
// Back to screen space, render some text
set_default_camera();
draw_text("HELLO", 30.0, 200.0, 30.0, BLACK);
next_frame().await
}
}
More examples
examples/3d.rs (line 41)
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
async fn main() {
let rust_logo = load_texture("examples/rust.png").await.unwrap();
let ferris = load_texture("examples/ferris.png").await.unwrap();
loop {
clear_background(LIGHTGRAY);
// Going 3d!
set_camera(&Camera3D {
position: vec3(-20., 15., 0.),
up: vec3(0., 1., 0.),
target: vec3(0., 0., 0.),
..Default::default()
});
draw_grid(20, 1., BLACK, GRAY);
draw_cube_wires(vec3(0., 1., -6.), vec3(2., 2., 2.), DARKGREEN);
draw_cube_wires(vec3(0., 1., 6.), vec3(2., 2., 2.), DARKBLUE);
draw_cube_wires(vec3(2., 1., 2.), vec3(2., 2., 2.), YELLOW);
draw_plane(vec3(-8., 0., -8.), vec2(5., 5.), Some(&ferris), WHITE);
draw_cube(
vec3(-5., 1., -2.),
vec3(2., 2., 2.),
Some(&rust_logo),
WHITE,
);
draw_cube(vec3(-5., 1., 2.), vec3(2., 2., 2.), Some(&ferris), WHITE);
draw_cube(vec3(2., 0., -2.), vec3(0.4, 0.4, 0.4), None, BLACK);
draw_sphere(vec3(-8., 0., 0.), 1., None, BLUE);
// Back to screen space, render some text
set_default_camera();
draw_text("WELCOME TO 3D WORLD", 10.0, 20.0, 30.0, BLACK);
next_frame().await
}
}
examples/post_processing.rs (line 35)
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
async fn main() {
let render_target = render_target(320, 150);
render_target.texture.set_filter(FilterMode::Nearest);
let material = load_material(
ShaderSource::Glsl {
vertex: CRT_VERTEX_SHADER,
fragment: CRT_FRAGMENT_SHADER,
},
Default::default(),
)
.unwrap();
loop {
// drawing to the texture
// 0..100, 0..100 camera
set_camera(&Camera2D {
zoom: vec2(0.01, 0.01),
target: vec2(0.0, 0.0),
render_target: Some(render_target.clone()),
..Default::default()
});
clear_background(LIGHTGRAY);
draw_line(-30.0, 45.0, 30.0, 45.0, 3.0, BLUE);
draw_circle(-45.0, -35.0, 20.0, YELLOW);
draw_circle(45.0, -35.0, 20.0, GREEN);
// drawing to the screen
set_default_camera();
clear_background(WHITE);
gl_use_material(&material);
draw_texture_ex(
&render_target.texture,
0.,
0.,
WHITE,
DrawTextureParams {
dest_size: Some(vec2(screen_width(), screen_height())),
..Default::default()
},
);
gl_use_default_material();
next_frame().await;
}
}
examples/raw_miniquad.rs (line 56)
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 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
async fn main() {
let stage = {
let InternalGlContext {
quad_context: ctx, ..
} = unsafe { get_internal_gl() };
raw_miniquad::Stage::new(ctx)
};
loop {
clear_background(LIGHTGRAY);
// Render some primitives in camera space
set_camera(&Camera2D {
zoom: vec2(1., screen_width() / screen_height()),
..Default::default()
});
draw_line(-0.4, 0.4, -0.8, 0.9, 0.05, BLUE);
draw_rectangle(-0.3, 0.3, 0.2, 0.2, GREEN);
draw_circle(0., 0., 0.1, YELLOW);
{
let mut gl = unsafe { get_internal_gl() };
// Ensure that macroquad's shapes are not going to be lost
gl.flush();
let t = get_time();
gl.quad_context.apply_pipeline(&stage.pipeline);
gl.quad_context
.begin_default_pass(miniquad::PassAction::Nothing);
gl.quad_context.apply_bindings(&stage.bindings);
for i in 0..10 {
let t = t + i as f64 * 0.3;
gl.quad_context
.apply_uniforms(miniquad::UniformsSource::table(
&raw_miniquad::shader::Uniforms {
offset: (t.sin() as f32 * 0.5, (t * 3.).cos() as f32 * 0.5),
},
));
gl.quad_context.draw(0, 6, 1);
}
gl.quad_context.end_render_pass();
}
// Back to screen space, render some text
set_default_camera();
draw_text("HELLO", 30.0, 200.0, 30.0, BLACK);
next_frame().await
}
}
examples/letterbox.rs (line 52)
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 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
async fn main() {
// Setup 'render_target', used to hold the rendering result so we can resize it
let render_target = render_target(VIRTUAL_WIDTH as u32, VIRTUAL_HEIGHT as u32);
render_target.texture.set_filter(FilterMode::Linear);
// Setup camera for the virtual screen, that will render to 'render_target'
let mut render_target_cam =
Camera2D::from_display_rect(Rect::new(0., 0., VIRTUAL_WIDTH, VIRTUAL_HEIGHT));
render_target_cam.render_target = Some(render_target.clone());
loop {
// Get required scaling value
let scale: f32 = f32::min(
screen_width() / VIRTUAL_WIDTH,
screen_height() / VIRTUAL_HEIGHT,
);
// Mouse position in the virtual screen
let virtual_mouse_pos = Vec2 {
x: (mouse_position().0 - (screen_width() - (VIRTUAL_WIDTH * scale)) * 0.5) / scale,
y: (mouse_position().1 - (screen_height() - (VIRTUAL_HEIGHT * scale)) * 0.5) / scale,
};
// ------------------------------------------------------------------------
// Begin drawing the virtual screen to 'render_target'
// ------------------------------------------------------------------------
set_camera(&render_target_cam);
clear_background(LIGHTGRAY);
draw_text("Hello Letterbox", 20.0, 20.0, 30.0, DARKGRAY);
draw_circle(VIRTUAL_WIDTH / 2.0 - 65.0, VIRTUAL_HEIGHT / 2.0, 35.0, RED);
draw_circle(VIRTUAL_WIDTH / 2.0 + 65.0, VIRTUAL_HEIGHT / 2.0, 35.0, BLUE);
draw_circle(
VIRTUAL_WIDTH / 2.0,
VIRTUAL_HEIGHT / 2.0 - 65.0,
35.0,
YELLOW,
);
draw_circle(virtual_mouse_pos.x, virtual_mouse_pos.y, 15.0, BLACK);
// ------------------------------------------------------------------------
// Begin drawing the window screen
// ------------------------------------------------------------------------
set_default_camera();
clear_background(BLACK); // Will be the letterbox color
// Draw 'render_target' to window screen, porperly scaled and letterboxed
draw_texture_ex(
&render_target.texture,
(screen_width() - (VIRTUAL_WIDTH * scale)) * 0.5,
(screen_height() - (VIRTUAL_HEIGHT * scale)) * 0.5,
WHITE,
DrawTextureParams {
dest_size: Some(vec2(VIRTUAL_WIDTH * scale, VIRTUAL_HEIGHT * scale)),
flip_y: true, // Must flip y otherwise 'render_target' will be upside down
..Default::default()
},
);
next_frame().await;
}
}
examples/first_person.rs (line 118)
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 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 126 127 128 129 130 131 132 133 134 135 136 137 138
async fn main() {
let mut x = 0.0;
let mut switch = false;
let bounds = 8.0;
let world_up = vec3(0.0, 1.0, 0.0);
let mut yaw: f32 = 1.18;
let mut pitch: f32 = 0.0;
let mut front = vec3(
yaw.cos() * pitch.cos(),
pitch.sin(),
yaw.sin() * pitch.cos(),
)
.normalize();
let mut right = front.cross(world_up).normalize();
let mut up;
let mut position = vec3(0.0, 1.0, 0.0);
let mut last_mouse_position: Vec2 = mouse_position().into();
let mut grabbed = true;
set_cursor_grab(grabbed);
show_mouse(false);
loop {
let delta = get_frame_time();
if is_key_pressed(KeyCode::Escape) {
break;
}
if is_key_pressed(KeyCode::Tab) {
grabbed = !grabbed;
set_cursor_grab(grabbed);
show_mouse(!grabbed);
}
if is_key_down(KeyCode::Up) {
position += front * MOVE_SPEED;
}
if is_key_down(KeyCode::Down) {
position -= front * MOVE_SPEED;
}
if is_key_down(KeyCode::Left) {
position -= right * MOVE_SPEED;
}
if is_key_down(KeyCode::Right) {
position += right * MOVE_SPEED;
}
let mouse_position: Vec2 = mouse_position().into();
let mouse_delta = mouse_position - last_mouse_position;
last_mouse_position = mouse_position;
yaw += mouse_delta.x * delta * LOOK_SPEED;
pitch += mouse_delta.y * delta * -LOOK_SPEED;
pitch = if pitch > 1.5 { 1.5 } else { pitch };
pitch = if pitch < -1.5 { -1.5 } else { pitch };
front = vec3(
yaw.cos() * pitch.cos(),
pitch.sin(),
yaw.sin() * pitch.cos(),
)
.normalize();
right = front.cross(world_up).normalize();
up = right.cross(front).normalize();
x += if switch { 0.04 } else { -0.04 };
if x >= bounds || x <= -bounds {
switch = !switch;
}
clear_background(LIGHTGRAY);
// Going 3d!
set_camera(&Camera3D {
position: position,
up: up,
target: position + front,
..Default::default()
});
draw_grid(20, 1., BLACK, GRAY);
draw_line_3d(
vec3(x, 0.0, x),
vec3(5.0, 5.0, 5.0),
Color::new(1.0, 1.0, 0.0, 1.0),
);
draw_cube_wires(vec3(0., 1., -6.), vec3(2., 2., 2.), GREEN);
draw_cube_wires(vec3(0., 1., 6.), vec3(2., 2., 2.), BLUE);
draw_cube_wires(vec3(2., 1., 2.), vec3(2., 2., 2.), RED);
// Back to screen space, render some text
set_default_camera();
draw_text("First Person Camera", 10.0, 20.0, 30.0, BLACK);
draw_text(
format!("X: {} Y: {}", mouse_position.x, mouse_position.y).as_str(),
10.0,
48.0 + 18.0,
30.0,
BLACK,
);
draw_text(
format!("Press <TAB> to toggle mouse grab: {}", grabbed).as_str(),
10.0,
48.0 + 42.0,
30.0,
BLACK,
);
next_frame().await
}
}
Additional examples can be found in: