Struct tiny_game_framework::Vector4D

pub struct Vector4D {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
}

Fields

x: f32

y: f32

z: f32

w: f32

Implementations

impl Vector4D

pub fn new(x: f32, y: f32, z: f32, w: f32) -> Self

Examples found in repository

examples/test_scene.rs (line 18)

fn main() {
    let mut el = EventLoop::new(500, 500);
    let mut renderer = Renderer::new();

    unsafe {
        Enable(BLEND);
        BlendFunc(SRC_ALPHA, ONE_MINUS_SRC_ALPHA); 
    }

    fn nome_aleatorio() -> String {
        format!("{:?}", rand_betw(0.0_f64, 1000.0_f64))
    }

    let mut c = Circle::new(32, Vector3D::new(0.0, 0.0, 0.0), 0.5, Vector4D::new(0.5, 1.0, 0.5, 0.2));
    c.add_to_renderer("oi", &mut renderer);
    
    let t = Triangle::new(Vector3D::new(1.0, 0.0, 0.0), 0.5, Vector4D::new(1.0, 1.0, 1.0, 0.6));
    t.add_to_renderer("trianglu", &mut renderer);

    let q = Quad::new(Vector3D::new(-1.0, 0.0, 0.0), Vector3D::new(0.5, 0.5, 0.5), Vector4D::new(0.5, 0.1, 0.1, 0.9));
    q.add_to_renderer("quda", &mut renderer);

    // let mut t = Triangle
    for i in 0..256 {
        let c = Circle::new(32, Vector3D::new(0.0, 0.0, 0.0), 0.1, Vector4D::new(1.0, 1.0, 1.0, 1.0));
        c.add_to_renderer(&format!("{:?}", i), &mut renderer);
    }
    
    let o = Once::new(); 
    let mut time: f32 = 0.0;
    while !el.window.should_close() {
        let now = std::time::Instant::now();

        el.update();
        renderer.update();

        if el.is_key_down(glfw::Key::I) {
            println!("{:?}", el.event_handler.mouse_pos.x / el.event_handler.width);
        }

        let mouse_pos = Vector3D::new(el.event_handler.mouse_pos.x / el.event_handler.width, el.event_handler.mouse_pos.y / el.event_handler.height, 0.0);

        unsafe {
            Clear(COLOR_BUFFER_BIT);

            renderer.draw();
            
            o.call_once(|| {
                for i in 0..256 {
                    renderer.destroy_mesh(&format!("{:?}", i));
                }
            });
        }

        time += now.elapsed().as_secs_f32();
    }
}

pub fn dot(self, other: Vector4D) -> f32

pub fn magnitude(self) -> f32

pub fn normalize(self) -> Self

Trait Implementations

impl Add for Vector4D

type Output = Vector4D

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl Clone for Vector4D

fn clone(&self) -> Vector4D

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Vector4D

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

Formats the value using the given formatter.

impl Div<f32> for Vector4D

type Output = Vector4D

The resulting type after applying the / operator.

fn div(self, scalar: f32) -> Self

Performs the / operation.

impl Mul<Vector4D> for Matrix4x4

type Output = Vector4D

The resulting type after applying the * operator.

fn mul(self, v: Vector4D) -> Vector4D

Performs the * operation.

impl Mul<f32> for Vector4D

type Output = Vector4D

The resulting type after applying the * operator.

fn mul(self, scalar: f32) -> Self

Performs the * operation.

impl PartialEq for Vector4D

fn eq(&self, other: &Vector4D) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub for Vector4D

type Output = Vector4D

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl Copy for Vector4D

impl StructuralPartialEq for Vector4D