Struct Vector2

#[repr(C)]
pub struct Vector2 {
    pub x: f32,
    pub y: f32,
}

Fields

x: f32

y: f32

Implementations

impl Vector2

pub const ZERO: Self

pub const ONE: Self

pub const UP: Self

pub const DOWN: Self

pub const LEFT: Self

pub const RIGHT: Self

pub fn new<T: ToPrimitive>(x: T, y: T) -> Self

Examples found in repository

examples/drawing.rs (line 34)

fn main() {
    let mut runner = est_render::runner::new().expect("Failed to create runner");

    let mut window = runner
        .create_window("Drawing Example", Point2::new(800, 600))
        .build()
        .expect("Failed to create window");

    let mut gpu = est_render::gpu::new(Some(&mut window))
        .build()
        .expect("Failed to create GPU");

    while runner.pool_events(None) {
        for event in runner.get_events() {
            match event {
                Event::WindowClosed { .. } => {
                    return;
                }
                _ => {}
            }
        }

        if let Ok(mut cmd) = gpu.begin_command() {
            if let Ok(mut gp) = cmd.begin_renderpass() {
                gp.set_clear_color(Color::BLUE); // Set the clear color to blue

                gp.set_blend(0, Some(&BlendState::ALPHA_BLEND));
                if let Some(mut drawing) = gp.begin_drawing() {
                    drawing.draw_rect_filled(
                        Vector2::new(100.0, 100.0),
                        Vector2::new(200.0, 200.0),
                        Color::RED,
                    );

                    drawing.draw_circle_filled(Vector2::new(400.0, 300.0), 50.0, 25, Color::GREEN);
                }

                gp.set_blend(0, Some(&BlendState::ADDITIVE_BLEND));
                if let Some(mut drawing) = gp.begin_drawing() {
                    drawing.draw_text(
                        "Hello, World!",
                        Vector2::new(300.0, 500.0),
                        Color::WHITE,
                    );
                }
            }
        }
    }
}

examples/font.rs (line 50)

fn main() {
    let mut runner = est_render::runner::new().expect("Failed to create runner");

    let mut window = runner
        .create_window("Font Example", Point2::new(800, 600))
        .build()
        .expect("Failed to create window");

    let mut gpu = est_render::gpu::new(Some(&mut window))
        .build()
        .expect("Failed to create GPU");

    let mut font_manager = est_render::font::new();

    let font = font_manager
        .load_font("Arial", None, 20.0)
        .expect("Failed to load font");

    // Generate baked text texture
    let texture = font
        .create_baked_text(&mut gpu, "Hello, World!\nThis is a clear color example.")
        .expect("Failed to create baked text");

    while runner.pool_events(None) {
        for event in runner.get_events() {
            match event {
                Event::WindowClosed { .. } => {
                    return;
                }
                _ => {}
            }
        }

        if let Ok(mut cmd) = gpu.begin_command() {
            if let Ok(mut gp) = cmd.begin_renderpass() {
                gp.set_clear_color(Color::BLUE);

                // The best texture blend for font rendering, others may has artifacts like black borders
                gp.set_blend(0, Some(&BlendState::ADDITIVE_BLEND));
                
                if let Some(mut drawing) = gp.begin_drawing() {
                    let size: Vector2 = texture.size().into();

                    // Baked text rendering
                    drawing.set_texture(Some(&texture));
                    drawing.draw_rect_image(Vector2::new(0.0, 0.0), size, Color::WHITE);

                    // Online text rendering
                    drawing.set_font(&font);
                    drawing.draw_text(
                        "Hello, World!\nThis is a clear color example.",
                        Vector2::new(size.x, 0.0),
                        Color::WHITE,
                    );
                }
            }
        }
    }
}

examples/texture_atlas.rs (line 48)

fn main() {
    let mut runner = est_render::runner::new().expect("Failed to create runner");

    let mut window = runner
        .create_window("Clear Color Example", Point2::new(800, 600))
        .build()
        .expect("Failed to create window");

    let mut gpu = est_render::gpu::new(Some(&mut window))
        .build()
        .expect("Failed to create GPU");

    let texture_atlas = gpu
        .create_texture_atlas()
        .add_texture_file(
            "example_texture",
            "./examples/resources/test1.png",
        )
        .add_texture_file(
            "example_texture2",
            "./examples/resources/test2.png",
        )
        .build()
        .expect("Failed to create texture atlas");

    while runner.pool_events(None) {
        for event in runner.get_events() {
            match event {
                Event::WindowClosed { .. } => {
                    return;
                }
                _ => {}
            }
        }

        if let Ok(mut cmd) = gpu.begin_command() {
            if let Ok(mut gp) = cmd.begin_renderpass() {
                gp.set_clear_color(Color::BLUEVIOLET);
                gp.set_blend(0, Some(&BlendState::NONE));

                if let Some(mut drawing) = gp.begin_drawing() {
                    drawing.set_texture_atlas(Some((&texture_atlas, "example_texture")));
                    drawing.draw_rect_image(
                        Vector2::new(100.0, 100.0),
                        Vector2::new(200.0, 200.0),
                        Color::WHITE,
                    );
                    drawing.set_texture_atlas(Some((&texture_atlas, "example_texture2")));
                    drawing.draw_rect_image(
                        Vector2::new(350.0, 100.0),
                        Vector2::new(200.0, 200.0),
                        Color::WHITE,
                    );
                    drawing.draw_circle_image(Vector2::new(600.0, 200.0), 100.0, 20, Color::WHITE);
                }
            }
        }
    }
}

examples/msaa.rs (line 108)

fn main() {
    let mut runner = est_render::runner::new().expect("Failed to create runner");
    let mut window = runner
        .create_window("Engine Example", Point2::new(800, 600))
        .build()
        .expect("Failed to create window");

    let mut gpu = est_render::gpu::new(Some(&mut window))
        .build()
        .expect("Failed to create GPU");

    let mut msaa_texture = Some(
        gpu.create_texture()
            .set_render_target(Point2::new(800, 600), None)
            .set_usage(TextureUsage::Sampler)
            .set_sample_count(SampleCount::SampleCount4)
            .build()
            .expect("Failed to create MSAA texture"),
    );

    let mut msaa_count = SampleCount::SampleCount4;
    let mut window_size = Point2::new(800, 600);

    while runner.pool_events(None) {
        for event in runner.get_events() {
            match event {
                Event::WindowClosed { .. } => {
                    return;
                }
                Event::KeyboardInput { key, pressed, .. } => {
                    if !*pressed {
                        continue;
                    }

                    let mut need_recreate = false;
                    if *key == "1" {
                        msaa_count = SampleCount::SampleCount1;
                        need_recreate = true;
                    }

                    if *key == "2" {
                        msaa_count = SampleCount::SampleCount2;
                        need_recreate = true;
                    }

                    if *key == "3" {
                        msaa_count = SampleCount::SampleCount4;
                        need_recreate = true;
                    }

                    if *key == "4" {
                        msaa_count = SampleCount::SampleCount8;
                        need_recreate = true;
                    }

                    if need_recreate {
                        if msaa_count == SampleCount::SampleCount1 {
                            msaa_texture = None;
                        } else {
                            msaa_texture = Some(
                                gpu.create_texture()
                                    .set_render_target(
                                        Point2::new(window_size.x, window_size.y),
                                        None,
                                    )
                                    .set_usage(TextureUsage::Sampler)
                                    .set_sample_count(msaa_count)
                                    .build()
                                    .expect("Failed to recreate MSAA texture"),
                            );
                        }
                    }
                }
                Event::WindowResized { size, .. } => {
                    if size.x <= 0 || size.y <= 0 {
                        eprintln!("Invalid window size: {:?}", size);
                        continue;
                    }

                    window_size = *size;

                    // Resize the MSAA texture to match the new window size
                    msaa_texture = Some(
                        gpu.create_texture()
                            .set_render_target(Point2::new(size.x, size.y), None)
                            .set_usage(TextureUsage::Sampler)
                            .set_sample_count(msaa_count)
                            .build()
                            .expect("Failed to resize MSAA texture"),
                    );
                }
                _ => {}
            }
        }

        if let Ok(mut cmd) = gpu.begin_command() {
            if let Ok(mut rp) = cmd.begin_renderpass() {
                rp.set_clear_color(Color::BLACK);
                if let Some(texture) = msaa_texture.as_ref() {
                    rp.push_msaa_texture(texture);
                }

                if let Some(mut drawing) = rp.begin_drawing() {
                    let pos1 = Vector2::new(0.0, 0.0);
                    let pos2 = Vector2::new(800.0, 0.0);
                    let pos3 = Vector2::new(400.0, 600.0);

                    // Draw a full triangle covering the window
                    drawing.draw_triangle_filled(pos1, pos2, pos3, Color::BLUE);
                }
            }
        }
    }
}

examples/pipeline.rs (line 123)

fn main() {
    let mut runner = est_render::runner::new().expect("Failed to create runner");
    let mut window = runner
        .create_window("Engine Example", Point2::new(800, 600))
        .build()
        .expect("Failed to create window");

    let mut gpu = est_render::gpu::new(Some(&mut window))
        .build()
        .expect("Failed to create GPU");

    let mut msaa_texture = gpu
        .create_texture()
        .set_render_target(Point2::new(800, 600), None)
        .set_sample_count(SampleCount::SampleCount4)
        .build()
        .expect("Failed to create MSAA texture");

    let blank_texture = gpu
        .create_texture()
        .set_raw_image(
            &[255u8; 4],
            Point2::new(1, 1),
            TextureFormat::Bgra8Unorm,
        )
        .set_usage(TextureUsage::Sampler)
        .build()
        .expect("Failed to create blank texture");

    let shader = gpu
        .create_graphics_shader()
        .set_vertex_code(VERTEX_DRAWING_SHADER)
        .set_fragment_code(FRAGMENT_DRAWING_SHADER)
        .build()
        .expect("Failed to create graphics shader");

    let compute_shader = gpu
        .create_compute_shader()
        .set_source(COMPUTE_NOOP_SHADER)
        .build()
        .expect("Failed to create compute shader");

    let pipeline = gpu
        .create_render_pipeline()
        .set_shader(Some(&shader))
        .set_blend(Some(&BlendState::ALPHA_BLEND))
        .set_attachment_texture(0, 0, Some(&blank_texture))
        .set_attachment_sampler(0, 1, Some(&TextureSampler::DEFAULT))
        .build()
        .expect("Failed to create render pipeline");

    let compute_pipeline = gpu
        .create_compute_pipeline()
        .set_shader(Some(&compute_shader))
        .build()
        .expect("Failed to create compute pipeline");

    // Triangle vertices
    let vertices = vec![
        Vertex {
            position: Vector3::new(-0.5, -0.5, 0.0),
            color: Color::new(1.0, 0.0, 0.0, 1.0),
            texcoord: Vector2::new(0.0, 1.0),
        },
        Vertex {
            position: Vector3::new(0.5, -0.5, 0.0),
            color: Color::new(0.0, 1.0, 0.0, 1.0),
            texcoord: Vector2::new(1.0, 1.0),
        },
        Vertex {
            position: Vector3::new(0.0, 0.5, 0.0),
            color: Color::new(0.0, 0.0, 1.0, 1.0),
            texcoord: Vector2::new(0.5, 0.0),
        },
    ];

    let indexes = vec![0u16, 1u16, 2u16];

    let vbo = gpu
        .create_buffer()
        .set_data_vec(vertices)
        .set_usage(BufferUsage::VERTEX)
        .build()
        .expect("Failed to create vertex buffer");

    let ibo = gpu
        .create_buffer()
        .set_data_vec(indexes)
        .set_usage(BufferUsage::INDEX)
        .build()
        .expect("Failed to create index buffer");

    while runner.pool_events(PollMode::WaitDraw) {
        for event in runner.get_events() {
            match event {
                Event::KeyboardInput {
                    window_id,
                    key,
                    pressed,
                } => {
                    if *window_id == window.id() && key == "Escape" && *pressed {
                        window.quit();
                    }
                }
                Event::WindowResized { window_id: _, size } => {
                    if size.x <= 0 || size.y <= 0 {
                        continue; // Skip invalid sizes
                    }

                    msaa_texture = gpu
                        .create_texture()
                        .set_render_target(Point2::new(size.x as u32, size.y as u32), None)
                        .set_sample_count(SampleCount::SampleCount4)
                        .build()
                        .expect("Failed to resize MSAA texture");
                }
                Event::RedrawRequested { window_id: _ } => {
                    if let Ok(mut cmd) = gpu.begin_command() {
                        if let Ok(mut cm) = cmd.begin_computepass() {
                            cm.set_pipeline(Some(&compute_pipeline));
                            cm.dispatch(1, 1, 1);
                        }

                        if let Ok(mut rp) = cmd.begin_renderpass() {
                            rp.set_clear_color(Color::BLACK);
                            rp.push_msaa_texture(&msaa_texture);

                            rp.set_pipeline(Some(&pipeline));
                            rp.set_gpu_buffer(Some(&vbo), Some(&ibo));
                            rp.draw_indexed(0..3, 0, 1);
                        }
                    }

                    window.request_redraw();
                }
                _ => {}
            }
        }
    }
}

pub fn length(&self) -> f32

pub fn normalize(&self) -> Self

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

pub fn angle(&self, other: &Self) -> f32

pub fn into_vector3(&self) -> Vector3

Trait Implementations

impl Add for Vector2

type Output = Vector2

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Vector2

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl Clone for Vector2

fn clone(&self) -> Vector2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Vector2

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

Formats the value using the given formatter.

impl Default for Vector2

fn default() -> Vector2

Returns the “default value” for a type.

impl Div<Vector2> for f32

type Output = Vector2

The resulting type after applying the / operator.

fn div(self, vector: Vector2) -> Vector2

Performs the / operation.

impl Div<f32> for Vector2

type Output = Vector2

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for Vector2

type Output = Vector2

The resulting type after applying the / operator.

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

Performs the / operation.

impl From<[f32; 2]> for Vector2

fn from(array: [f32; 2]) -> Self

Converts to this type from the input type.

impl From<(f32, f32)> for Vector2

fn from(tuple: (f32, f32)) -> Self

Converts to this type from the input type.

impl From<(f32, f32, f32)> for Vector2

fn from(tuple: (f32, f32, f32)) -> Self

Converts to this type from the input type.

impl From<(i32, i32)> for Vector2

fn from(tuple: (i32, i32)) -> Self

Converts to this type from the input type.

impl From<(u32, u32)> for Vector2

fn from(tuple: (u32, u32)) -> Self

Converts to this type from the input type.

impl From<Point2> for Vector2

fn from(point: Point2) -> Self

Converts to this type from the input type.

impl From<Vector2> for Point2

fn from(vector: Vector2) -> Self

Converts to this type from the input type.

impl From<Vector2> for Vector3

fn from(vector: Vector2) -> Self

Converts to this type from the input type.

impl From<Vector3> for Vector2

fn from(vector: Vector3) -> Self

Converts to this type from the input type.

impl Mul<Vector2> for Matrix4

type Output = Vector2

The resulting type after applying the * operator.

fn mul(self, rhs: Vector2) -> Vector2

Performs the * operation.

impl Mul<Vector2> for f32

type Output = Vector2

The resulting type after applying the * operator.

fn mul(self, vector: Vector2) -> Vector2

Performs the * operation.

impl Mul<f32> for Vector2

type Output = Vector2

The resulting type after applying the * operator.

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

Performs the * operation.

impl PartialEq for Vector2

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Sub<f32> for Vector2

type Output = Vector2

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Vector2

type Output = Vector2

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Vector2

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl Zeroable for Vector2

fn zeroed() -> Self

Calls zeroed.

impl Copy for Vector2

impl Eq for Vector2

impl Pod for Vector2