Function macroquad::camera::set_camera
source · pub fn set_camera(camera: &dyn Camera)
Expand description
Set active 2D or 3D camera.
Examples found in repository?
examples/tree.rs (line 37)
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
async fn main() {
let camera = Camera2D {
zoom: vec2(1., 1.),
target: vec2(0.0, 0.5),
..Default::default()
};
set_camera(&camera);
loop {
clear_background(LIGHTGRAY);
draw_circle(0., 0., 0.03, DARKGRAY);
tree(unsafe { get_internal_gl().quad_gl }, get_time(), 0, 1., 0.3);
next_frame().await
}
}
More examples
examples/camera.rs (lines 10-13)
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
}
}
examples/3d.rs (lines 13-18)
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 (lines 21-26)
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 (lines 18-21)
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 33)
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;
}
}
Additional examples can be found in: