chaos_framework

Struct Camera

Source 
pub struct Camera {
    pub proj: Mat4,
    pub view: Mat4,
    pub pos: Vec3,
    pub right: Vec3,
    pub front: Vec3,
    pub up: Vec3,
    pub pitch: f32,
    pub yaw: f32,
    pub speed: f32,
    pub dt: f32,
    /* private fields */
}

Fields§

§proj: Mat4§view: Mat4§pos: Vec3§right: Vec3§front: Vec3§up: Vec3§pitch: f32§yaw: f32§speed: f32§dt: f32

Implementations§

Source§

impl Camera

Source

pub fn new() -> Self

Source

pub fn update(&mut self, y: Vec3, el: &EventLoop)

Examples found in repository?
examples/simple2d.rs (line 29)
8fn main() {
9    let mut el = EventLoop::new(600, 600);
10    let mut renderer = Renderer::new();
11
12    /* default projection type is perspective */
13    renderer.camera.set_projection(ProjectionType::Orthographic);
14    renderer.add_light(Light { position: vec3(0.0, 0.0, 1.0), color: Vec3::ONE })
15        .unwrap();
16
17    /* we'll represent our player using a quad */
18    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
19        .unwrap();
20
21    while !el.window.should_close() {
22        el.update();
23
24        /* we can modify the player by indexing into it in the renderer's meshes */
25        let player = &mut renderer.meshes[player_handle];
26        player.color = vec3(0.5, 0.0, el.time.sin());
27        move_player(&el, &mut player.position);
28    
29        renderer.camera.update(Vec3::ZERO, &el);
30    
31        let frame = el.ui.frame(&mut el.window);
32        frame.text("hello, world! this is imgui");
33
34        unsafe {
35            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
36            ClearColor(0.1, 0.2, 0.3, 1.0);
37            
38            renderer.draw();
39            el.ui.draw();
40        }
41    }
42}
More examples
Hide additional examples
examples/ik.rs (line 83)
7fn main() {
8    let mut el = EventLoop::new(600, 600);
9    let mut renderer = Renderer::new();
10
11    unsafe {
12        Enable(DEPTH_TEST);
13    }
14
15    /* default projection type is perspective */
16    renderer.camera.set_projection(ProjectionType::Orthographic);
17    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
18        .unwrap();
19
20    /* we'll represent our player using a quad */
21    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
22        .unwrap();
23
24    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything
25
26    let mut segments = vec![];
27    for _ in 0..128 {
28        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);
29
30        segments.push(new_segment);
31    }
32
33    renderer.meshes[segments[0].handle].hidden = true;
34    renderer.meshes[segments[segments.len()-1].handle].hidden = true;
35
36    renderer.meshes[player_handle].hidden = true;
37    
38
39    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);
40
41    let mut clamped_pos;
42    let mut player_vel;
43    let mut old_pos = Vec3::ZERO;
44
45    while !el.window.should_close() {
46        el.update();
47        renderer.update();
48        
49        segments.iter_mut().for_each(|s| {
50            s.update(&mut renderer);
51        });
52        
53        let player = &mut renderer.meshes[player_handle];
54        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
55        let clamped_player_pos = {
56            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
57            clamped_pos = player.position;
58
59            vec3(clamped_pos.x, clamped_pos.y, 0.0)
60        };
61        fabrik(&mut segments, {
62            if el.event_handler.lmb {
63                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
64            } else {
65                clamped_player_pos
66            }
67        }, 0.0, 2);
68
69        let first_segment_position = segments[0].pos;
70        let seg_amm = segments.len() as f32;
71        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
72        let len = segments[0].length;
73        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
74            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
75        }
76
77        player_vel = player.position - old_pos;
78        old_pos = player.position;
79
80        player.color = vec3(0.5, 0.0, el.time.sin());
81        move_player(&el, &mut player.position);
82    
83        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
84        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);
85
86        let frame = el.ui.frame(&mut el.window);
87        frame.text("Hello, world! This is imgui.");
88        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));
89
90        unsafe {
91            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
92            ClearColor(0.1, 0.2, 0.3, 1.0);
93            
94            renderer.draw();
95            el.ui.draw();
96        }
97    }
98}
Source

pub fn input(&mut self, el: &EventLoop)

Source

pub fn mouse_callback(&mut self, pos: Vec2, window: &Window)

Examples found in repository?
examples/ik.rs (line 84)
7fn main() {
8    let mut el = EventLoop::new(600, 600);
9    let mut renderer = Renderer::new();
10
11    unsafe {
12        Enable(DEPTH_TEST);
13    }
14
15    /* default projection type is perspective */
16    renderer.camera.set_projection(ProjectionType::Orthographic);
17    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
18        .unwrap();
19
20    /* we'll represent our player using a quad */
21    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
22        .unwrap();
23
24    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything
25
26    let mut segments = vec![];
27    for _ in 0..128 {
28        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);
29
30        segments.push(new_segment);
31    }
32
33    renderer.meshes[segments[0].handle].hidden = true;
34    renderer.meshes[segments[segments.len()-1].handle].hidden = true;
35
36    renderer.meshes[player_handle].hidden = true;
37    
38
39    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);
40
41    let mut clamped_pos;
42    let mut player_vel;
43    let mut old_pos = Vec3::ZERO;
44
45    while !el.window.should_close() {
46        el.update();
47        renderer.update();
48        
49        segments.iter_mut().for_each(|s| {
50            s.update(&mut renderer);
51        });
52        
53        let player = &mut renderer.meshes[player_handle];
54        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
55        let clamped_player_pos = {
56            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
57            clamped_pos = player.position;
58
59            vec3(clamped_pos.x, clamped_pos.y, 0.0)
60        };
61        fabrik(&mut segments, {
62            if el.event_handler.lmb {
63                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
64            } else {
65                clamped_player_pos
66            }
67        }, 0.0, 2);
68
69        let first_segment_position = segments[0].pos;
70        let seg_amm = segments.len() as f32;
71        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
72        let len = segments[0].length;
73        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
74            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
75        }
76
77        player_vel = player.position - old_pos;
78        old_pos = player.position;
79
80        player.color = vec3(0.5, 0.0, el.time.sin());
81        move_player(&el, &mut player.position);
82    
83        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
84        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);
85
86        let frame = el.ui.frame(&mut el.window);
87        frame.text("Hello, world! This is imgui.");
88        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));
89
90        unsafe {
91            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
92            ClearColor(0.1, 0.2, 0.3, 1.0);
93            
94            renderer.draw();
95            el.ui.draw();
96        }
97    }
98}
Source

pub unsafe fn send_uniforms(&self, shader: &Shader)

Source

pub fn set_projection(&mut self, projection_type: ProjectionType)

Examples found in repository?
examples/simple2d.rs (line 13)
8fn main() {
9    let mut el = EventLoop::new(600, 600);
10    let mut renderer = Renderer::new();
11
12    /* default projection type is perspective */
13    renderer.camera.set_projection(ProjectionType::Orthographic);
14    renderer.add_light(Light { position: vec3(0.0, 0.0, 1.0), color: Vec3::ONE })
15        .unwrap();
16
17    /* we'll represent our player using a quad */
18    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
19        .unwrap();
20
21    while !el.window.should_close() {
22        el.update();
23
24        /* we can modify the player by indexing into it in the renderer's meshes */
25        let player = &mut renderer.meshes[player_handle];
26        player.color = vec3(0.5, 0.0, el.time.sin());
27        move_player(&el, &mut player.position);
28    
29        renderer.camera.update(Vec3::ZERO, &el);
30    
31        let frame = el.ui.frame(&mut el.window);
32        frame.text("hello, world! this is imgui");
33
34        unsafe {
35            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
36            ClearColor(0.1, 0.2, 0.3, 1.0);
37            
38            renderer.draw();
39            el.ui.draw();
40        }
41    }
42}
More examples
Hide additional examples
examples/ik.rs (line 16)
7fn main() {
8    let mut el = EventLoop::new(600, 600);
9    let mut renderer = Renderer::new();
10
11    unsafe {
12        Enable(DEPTH_TEST);
13    }
14
15    /* default projection type is perspective */
16    renderer.camera.set_projection(ProjectionType::Orthographic);
17    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
18        .unwrap();
19
20    /* we'll represent our player using a quad */
21    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
22        .unwrap();
23
24    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything
25
26    let mut segments = vec![];
27    for _ in 0..128 {
28        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);
29
30        segments.push(new_segment);
31    }
32
33    renderer.meshes[segments[0].handle].hidden = true;
34    renderer.meshes[segments[segments.len()-1].handle].hidden = true;
35
36    renderer.meshes[player_handle].hidden = true;
37    
38
39    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);
40
41    let mut clamped_pos;
42    let mut player_vel;
43    let mut old_pos = Vec3::ZERO;
44
45    while !el.window.should_close() {
46        el.update();
47        renderer.update();
48        
49        segments.iter_mut().for_each(|s| {
50            s.update(&mut renderer);
51        });
52        
53        let player = &mut renderer.meshes[player_handle];
54        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
55        let clamped_player_pos = {
56            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
57            clamped_pos = player.position;
58
59            vec3(clamped_pos.x, clamped_pos.y, 0.0)
60        };
61        fabrik(&mut segments, {
62            if el.event_handler.lmb {
63                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
64            } else {
65                clamped_player_pos
66            }
67        }, 0.0, 2);
68
69        let first_segment_position = segments[0].pos;
70        let seg_amm = segments.len() as f32;
71        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
72        let len = segments[0].length;
73        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
74            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
75        }
76
77        player_vel = player.position - old_pos;
78        old_pos = player.position;
79
80        player.color = vec3(0.5, 0.0, el.time.sin());
81        move_player(&el, &mut player.position);
82    
83        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
84        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);
85
86        let frame = el.ui.frame(&mut el.window);
87        frame.text("Hello, world! This is imgui.");
88        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));
89
90        unsafe {
91            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
92            ClearColor(0.1, 0.2, 0.3, 1.0);
93            
94            renderer.draw();
95            el.ui.draw();
96        }
97    }
98}

Trait Implementations§

Source§

impl Clone for Camera

Source§

fn clone(&self) -> Camera

Returns a copy of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for Camera

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl Copy for Camera

Auto Trait Implementations§

§

impl Freeze for Camera

§

impl RefUnwindSafe for Camera

§

impl Send for Camera

§

impl Sync for Camera

§

impl Unpin for Camera

§

impl UnwindSafe for Camera

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V