Struct Point2

pub struct Point2 {
    pub x: i32,
    pub y: i32,
}

Fields

x: i32

y: i32

Implementations

impl Point2

pub const ZERO: Self

pub const ONE: Self

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

Examples found in repository

examples/software.rs (line 9)

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 sw = est_render::software::new(Some(&mut window))
        .build()
        .expect("Failed to create pixel buffer");

    let mut pixels = vec![128u32; (800 * 600) as usize];
    let mut size_px = Point2::new(800.0, 600.0);

    while runner.pool_events(None) {
        for event in runner.get_events() {
            match event {
                Event::WindowClosed { .. } => {
                    return;
                }
                Event::WindowResized { size, .. } => {
                    pixels.resize((size.x * size.y) as usize, 128);
                    size_px = Point2::new(size.x as f32, size.y as f32);
                }
                _ => {}
            }
        }

        if let Err(e) = sw.write_buffers(&pixels, size_px) {
            eprintln!("Error writing buffers: {}", e);
        }
    }
}

examples/clear_color.rs (line 9)

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");

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

        if let Ok(mut cmd) = gpu.begin_command() {
            let surface = cmd.get_surface_texture();
            if surface.is_err() {
                println!("Failed to get surface texture: {:?}", surface.err());
                continue;
            }

            // Or you could use `cmd.begin_renderpass()` directly
            if let Ok(mut rp) = cmd.renderpass_builder()
                .add_surface_color_attachment(surface.as_ref().unwrap(), Some(&BlendState::ALPHA_BLEND))
                .build() 
            {
                rp.set_clear_color(Color::BLUE);
            }
        }
    }
}

examples/gpu_adapter.rs (line 8)

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 adapters = est_render::gpu::query_gpu_adapter(Some(&window));
    if adapters.is_empty() {
        eprintln!("No GPU adapters found. Exiting.");
        return;
    }

    let selected_adapter = adapters
        .iter()
        .find(|adapter| adapter.backend_enum == AdapterBackend::Vulkan)
        .cloned();

    if selected_adapter.is_none() {
        eprintln!("No suitable GPU adapter found. Exiting.");
        return;
    }

    let adapter = selected_adapter.unwrap();
    let mut gpu = est_render::gpu::new(Some(&mut window))
        .set_adapter(&adapter)
        .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 rp) = cmd.begin_renderpass() {
                rp.set_clear_color(Color::LIGHTBLUE);
            }
        }
    }
}

examples/drawing.rs (line 9)

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 9)

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 9)

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);
                }
            }
        }
    }
}

Additional examples can be found in:

• examples/msaa.rs
• examples/pipeline.rs

Trait Implementations

impl Clone for Point2

fn clone(&self) -> Point2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Point2

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

Formats the value using the given formatter.

impl Default for Point2

fn default() -> Self

Returns the “default value” for a type.

impl From<(i32, i32)> for Point2

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

Converts to this type from the input type.

impl From<(u32, u32)> for Point2

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

Converts to this type from the input type.

impl From<PhysicalSize<i32>> for Point2

fn from(size: PhysicalSize<i32>) -> Self

Converts to this type from the input type.

impl From<PhysicalSize<u32>> for Point2

fn from(size: PhysicalSize<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<Point2> for Vector2I

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<Vector2I> for Point2

fn from(vector: Vector2I) -> Self

Converts to this type from the input type.

impl Into<Extent3d> for Point2

fn into(self) -> Extent3d

Converts this type into the (usually inferred) input type.

impl Into<PhysicalSize<i32>> for Point2

fn into(self) -> PhysicalSize<i32>

Converts this type into the (usually inferred) input type.

impl Into<PhysicalSize<u32>> for Point2

fn into(self) -> PhysicalSize<u32>

Converts this type into the (usually inferred) input type.

impl Ord for Point2

fn cmp(&self, other: &Point2) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Point2

fn eq(&self, other: &Point2) -> 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 PartialOrd for Point2

fn partial_cmp(&self, other: &Point2) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Point2

impl Eq for Point2

impl StructuralPartialEq for Point2