Struct DrawHandle 

pub struct DrawHandle<'a> {
    pub draw: RaylibDrawHandle<'a>,
}

Handle de dibujo (Raylib = Pincel)

Se obtiene de RyditGfx::begin_draw() y se usa para dibujar. Al salir de scope, automáticamente finaliza el dibujo.

Fields

draw: RaylibDrawHandle<'a>

Implementations

impl<'a> DrawHandle<'a>

pub fn clear(&mut self, color: ColorRydit)

Limpiar con color

Examples found in repository

examples/demo.rs (line 29)

fn main() {
    println!("=== RYDIT-GFX v0.1.0 ===");
    println!("Rust = Arquitecto, Raylib = Pincel\n");

    // Crear ventana (Rust controla)
    let mut gfx = RyditGfx::new("RyDit v0.0.7 - rydit-gfx", 800, 600);
    gfx.set_target_fps(60);

    println!("[RUST] Ventana creada, iniciando game loop...\n");

    // Game loop controlado por Rust
    let mut frame = 0;
    while !gfx.should_close() {
        frame += 1;

        // Rust decide input PRIMERO (antes de dibujar)
        let escape_pressed = gfx.is_key_pressed(Key::Escape);

        // Iniciar dibujo (toma &mut self, no podemos usar gfx después)
        {
            let mut d = gfx.begin_draw();

            // Limpiar pantalla
            d.clear(ColorRydit::Negro);

            // Dibujar círculo rojo en el centro (animado)
            let radius = 50 + (frame % 20);
            d.draw_circle(400, 300, radius, ColorRydit::Rojo);

            // Dibujar rectángulo verde
            d.draw_rectangle(100, 100, 100, 100, ColorRydit::Verde);

            // Dibujar línea azul
            d.draw_line(0, 0, 800, 600, ColorRydit::Azul);

            // Dibujar texto
            d.draw_text(
                "RyDit v0.0.7 - rydit-gfx",
                250,
                50,
                20,
                ColorRydit::Amarillo,
            );
            d.draw_text(
                "Rust = Arquitecto, Raylib = Pincel",
                220,
                80,
                16,
                ColorRydit::Blanco,
            );
            d.draw_text("Presiona ESC para salir", 280, 550, 16, ColorRydit::Blanco);

            // d se va de scope aquí, finaliza dibujo
        }

        // Rust decide después de dibujar
        if escape_pressed {
            println!("\n[RUST] Decidiendo cerrar en frame {}...", frame);
            break;
        }
    }

    println!("\n[RUST] Juego terminado. ¡Éxito!");
}

pub fn draw_circle(&mut self, x: i32, y: i32, radius: i32, color: ColorRydit)

Dibujar círculo

Examples found in repository

examples/demo.rs (line 33)

fn main() {
    println!("=== RYDIT-GFX v0.1.0 ===");
    println!("Rust = Arquitecto, Raylib = Pincel\n");

    // Crear ventana (Rust controla)
    let mut gfx = RyditGfx::new("RyDit v0.0.7 - rydit-gfx", 800, 600);
    gfx.set_target_fps(60);

    println!("[RUST] Ventana creada, iniciando game loop...\n");

    // Game loop controlado por Rust
    let mut frame = 0;
    while !gfx.should_close() {
        frame += 1;

        // Rust decide input PRIMERO (antes de dibujar)
        let escape_pressed = gfx.is_key_pressed(Key::Escape);

        // Iniciar dibujo (toma &mut self, no podemos usar gfx después)
        {
            let mut d = gfx.begin_draw();

            // Limpiar pantalla
            d.clear(ColorRydit::Negro);

            // Dibujar círculo rojo en el centro (animado)
            let radius = 50 + (frame % 20);
            d.draw_circle(400, 300, radius, ColorRydit::Rojo);

            // Dibujar rectángulo verde
            d.draw_rectangle(100, 100, 100, 100, ColorRydit::Verde);

            // Dibujar línea azul
            d.draw_line(0, 0, 800, 600, ColorRydit::Azul);

            // Dibujar texto
            d.draw_text(
                "RyDit v0.0.7 - rydit-gfx",
                250,
                50,
                20,
                ColorRydit::Amarillo,
            );
            d.draw_text(
                "Rust = Arquitecto, Raylib = Pincel",
                220,
                80,
                16,
                ColorRydit::Blanco,
            );
            d.draw_text("Presiona ESC para salir", 280, 550, 16, ColorRydit::Blanco);

            // d se va de scope aquí, finaliza dibujo
        }

        // Rust decide después de dibujar
        if escape_pressed {
            println!("\n[RUST] Decidiendo cerrar en frame {}...", frame);
            break;
        }
    }

    println!("\n[RUST] Juego terminado. ¡Éxito!");
}

pub fn draw_rectangle( &mut self, x: i32, y: i32, w: i32, h: i32, color: ColorRydit, )

Dibujar rectángulo

Examples found in repository

examples/demo.rs (line 36)

fn main() {
    println!("=== RYDIT-GFX v0.1.0 ===");
    println!("Rust = Arquitecto, Raylib = Pincel\n");

    // Crear ventana (Rust controla)
    let mut gfx = RyditGfx::new("RyDit v0.0.7 - rydit-gfx", 800, 600);
    gfx.set_target_fps(60);

    println!("[RUST] Ventana creada, iniciando game loop...\n");

    // Game loop controlado por Rust
    let mut frame = 0;
    while !gfx.should_close() {
        frame += 1;

        // Rust decide input PRIMERO (antes de dibujar)
        let escape_pressed = gfx.is_key_pressed(Key::Escape);

        // Iniciar dibujo (toma &mut self, no podemos usar gfx después)
        {
            let mut d = gfx.begin_draw();

            // Limpiar pantalla
            d.clear(ColorRydit::Negro);

            // Dibujar círculo rojo en el centro (animado)
            let radius = 50 + (frame % 20);
            d.draw_circle(400, 300, radius, ColorRydit::Rojo);

            // Dibujar rectángulo verde
            d.draw_rectangle(100, 100, 100, 100, ColorRydit::Verde);

            // Dibujar línea azul
            d.draw_line(0, 0, 800, 600, ColorRydit::Azul);

            // Dibujar texto
            d.draw_text(
                "RyDit v0.0.7 - rydit-gfx",
                250,
                50,
                20,
                ColorRydit::Amarillo,
            );
            d.draw_text(
                "Rust = Arquitecto, Raylib = Pincel",
                220,
                80,
                16,
                ColorRydit::Blanco,
            );
            d.draw_text("Presiona ESC para salir", 280, 550, 16, ColorRydit::Blanco);

            // d se va de scope aquí, finaliza dibujo
        }

        // Rust decide después de dibujar
        if escape_pressed {
            println!("\n[RUST] Decidiendo cerrar en frame {}...", frame);
            break;
        }
    }

    println!("\n[RUST] Juego terminado. ¡Éxito!");
}

pub fn draw_line( &mut self, x1: i32, y1: i32, x2: i32, y2: i32, color: ColorRydit, )

Dibujar línea

Examples found in repository

examples/demo.rs (line 39)

fn main() {
    println!("=== RYDIT-GFX v0.1.0 ===");
    println!("Rust = Arquitecto, Raylib = Pincel\n");

    // Crear ventana (Rust controla)
    let mut gfx = RyditGfx::new("RyDit v0.0.7 - rydit-gfx", 800, 600);
    gfx.set_target_fps(60);

    println!("[RUST] Ventana creada, iniciando game loop...\n");

    // Game loop controlado por Rust
    let mut frame = 0;
    while !gfx.should_close() {
        frame += 1;

        // Rust decide input PRIMERO (antes de dibujar)
        let escape_pressed = gfx.is_key_pressed(Key::Escape);

        // Iniciar dibujo (toma &mut self, no podemos usar gfx después)
        {
            let mut d = gfx.begin_draw();

            // Limpiar pantalla
            d.clear(ColorRydit::Negro);

            // Dibujar círculo rojo en el centro (animado)
            let radius = 50 + (frame % 20);
            d.draw_circle(400, 300, radius, ColorRydit::Rojo);

            // Dibujar rectángulo verde
            d.draw_rectangle(100, 100, 100, 100, ColorRydit::Verde);

            // Dibujar línea azul
            d.draw_line(0, 0, 800, 600, ColorRydit::Azul);

            // Dibujar texto
            d.draw_text(
                "RyDit v0.0.7 - rydit-gfx",
                250,
                50,
                20,
                ColorRydit::Amarillo,
            );
            d.draw_text(
                "Rust = Arquitecto, Raylib = Pincel",
                220,
                80,
                16,
                ColorRydit::Blanco,
            );
            d.draw_text("Presiona ESC para salir", 280, 550, 16, ColorRydit::Blanco);

            // d se va de scope aquí, finaliza dibujo
        }

        // Rust decide después de dibujar
        if escape_pressed {
            println!("\n[RUST] Decidiendo cerrar en frame {}...", frame);
            break;
        }
    }

    println!("\n[RUST] Juego terminado. ¡Éxito!");
}

pub fn draw_text( &mut self, text: &str, x: i32, y: i32, size: i32, color: ColorRydit, )

Dibujar texto

Examples found in repository

examples/demo.rs (lines 42-48)

fn main() {
    println!("=== RYDIT-GFX v0.1.0 ===");
    println!("Rust = Arquitecto, Raylib = Pincel\n");

    // Crear ventana (Rust controla)
    let mut gfx = RyditGfx::new("RyDit v0.0.7 - rydit-gfx", 800, 600);
    gfx.set_target_fps(60);

    println!("[RUST] Ventana creada, iniciando game loop...\n");

    // Game loop controlado por Rust
    let mut frame = 0;
    while !gfx.should_close() {
        frame += 1;

        // Rust decide input PRIMERO (antes de dibujar)
        let escape_pressed = gfx.is_key_pressed(Key::Escape);

        // Iniciar dibujo (toma &mut self, no podemos usar gfx después)
        {
            let mut d = gfx.begin_draw();

            // Limpiar pantalla
            d.clear(ColorRydit::Negro);

            // Dibujar círculo rojo en el centro (animado)
            let radius = 50 + (frame % 20);
            d.draw_circle(400, 300, radius, ColorRydit::Rojo);

            // Dibujar rectángulo verde
            d.draw_rectangle(100, 100, 100, 100, ColorRydit::Verde);

            // Dibujar línea azul
            d.draw_line(0, 0, 800, 600, ColorRydit::Azul);

            // Dibujar texto
            d.draw_text(
                "RyDit v0.0.7 - rydit-gfx",
                250,
                50,
                20,
                ColorRydit::Amarillo,
            );
            d.draw_text(
                "Rust = Arquitecto, Raylib = Pincel",
                220,
                80,
                16,
                ColorRydit::Blanco,
            );
            d.draw_text("Presiona ESC para salir", 280, 550, 16, ColorRydit::Blanco);

            // d se va de scope aquí, finaliza dibujo
        }

        // Rust decide después de dibujar
        if escape_pressed {
            println!("\n[RUST] Decidiendo cerrar en frame {}...", frame);
            break;
        }
    }

    println!("\n[RUST] Juego terminado. ¡Éxito!");
}

pub fn draw_triangle( &mut self, v1: (i32, i32), v2: (i32, i32), v3: (i32, i32), color: ColorRydit, )

Dibujar triángulo

pub fn draw_triangle_lines( &mut self, v1: (i32, i32), v2: (i32, i32), v3: (i32, i32), color: ColorRydit, )

Dibujar triángulo con líneas (outline)

pub fn draw_rectangle_lines( &mut self, x: i32, y: i32, w: i32, h: i32, color: ColorRydit, )

Dibujar rectángulo con líneas (outline)

pub fn draw_ring( &mut self, center: (i32, i32), _inner_radius: i32, outer_radius: i32, color: ColorRydit, )

Dibujar anillo (ring)

pub fn draw_ellipse( &mut self, center: (i32, i32), radius_h: i32, radius_v: i32, color: ColorRydit, )

Dibujar elipse

pub fn draw_line_thick( &mut self, start_pos: (i32, i32), end_pos: (i32, i32), thick: f32, color: ColorRydit, )

Dibujar línea gruesa

pub fn draw_rectangle_pro( &mut self, x: i32, y: i32, width: i32, height: i32, angle: f32, color: ColorRydit, )

Dibujar rectángulo rotado

pub fn draw_texture_ex( &mut self, texture: &Texture2D, position: Vector2, rotation: f32, scale: f32, color: Color, )

Dibujar textura avanzada

Trait Implementations

impl<'a> Drop for DrawHandle<'a>

fn drop(&mut self)

Executes the destructor for this type.