Struct Imgui

pub struct Imgui {
    pub ctx: Context,
    /* private fields */
}

Fields

ctx: Context

Implementations

impl Imgui

pub fn new(window: &mut Window) -> Self

pub fn frame(&mut self, window: &mut Window) -> &mut Ui

Examples found in repository

examples/simple2d.rs (line 31)

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

    /* default projection type is perspective */
    renderer.camera.set_projection(ProjectionType::Orthographic);
    renderer.add_light(Light { position: vec3(0.0, 0.0, 1.0), color: Vec3::ONE })
        .unwrap();

    /* we'll represent our player using a quad */
    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
        .unwrap();

    while !el.window.should_close() {
        el.update();

        /* we can modify the player by indexing into it in the renderer's meshes */
        let player = &mut renderer.meshes[player_handle];
        player.color = vec3(0.5, 0.0, el.time.sin());
        move_player(&el, &mut player.position);
    
        renderer.camera.update(Vec3::ZERO, &el);
    
        let frame = el.ui.frame(&mut el.window);
        frame.text("hello, world! this is imgui");

        unsafe {
            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
            ClearColor(0.1, 0.2, 0.3, 1.0);
            
            renderer.draw();
            el.ui.draw();
        }
    }
}

examples/ik.rs (line 86)

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

    unsafe {
        Enable(DEPTH_TEST);
    }

    /* default projection type is perspective */
    renderer.camera.set_projection(ProjectionType::Orthographic);
    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
        .unwrap();

    /* we'll represent our player using a quad */
    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
        .unwrap();

    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything

    let mut segments = vec![];
    for _ in 0..128 {
        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);

        segments.push(new_segment);
    }

    renderer.meshes[segments[0].handle].hidden = true;
    renderer.meshes[segments[segments.len()-1].handle].hidden = true;

    renderer.meshes[player_handle].hidden = true;
    

    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);

    let mut clamped_pos;
    let mut player_vel;
    let mut old_pos = Vec3::ZERO;

    while !el.window.should_close() {
        el.update();
        renderer.update();
        
        segments.iter_mut().for_each(|s| {
            s.update(&mut renderer);
        });
        
        let player = &mut renderer.meshes[player_handle];
        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
        let clamped_player_pos = {
            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
            clamped_pos = player.position;

            vec3(clamped_pos.x, clamped_pos.y, 0.0)
        };
        fabrik(&mut segments, {
            if el.event_handler.lmb {
                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
            } else {
                clamped_player_pos
            }
        }, 0.0, 2);

        let first_segment_position = segments[0].pos;
        let seg_amm = segments.len() as f32;
        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
        let len = segments[0].length;
        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
        }

        player_vel = player.position - old_pos;
        old_pos = player.position;

        player.color = vec3(0.5, 0.0, el.time.sin());
        move_player(&el, &mut player.position);
    
        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);

        let frame = el.ui.frame(&mut el.window);
        frame.text("Hello, world! This is imgui.");
        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));

        unsafe {
            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
            ClearColor(0.1, 0.2, 0.3, 1.0);
            
            renderer.draw();
            el.ui.draw();
        }
    }
}

pub fn on_mouse_move(&mut self, xpos: f32, ypos: f32)

pub fn on_mouse_click(&mut self, button: MouseButton, action: Action)

pub fn on_mouse_scroll(&mut self, x: f32, y: f32)

pub fn draw(&mut self)

Examples found in repository

examples/simple2d.rs (line 39)

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

    /* default projection type is perspective */
    renderer.camera.set_projection(ProjectionType::Orthographic);
    renderer.add_light(Light { position: vec3(0.0, 0.0, 1.0), color: Vec3::ONE })
        .unwrap();

    /* we'll represent our player using a quad */
    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
        .unwrap();

    while !el.window.should_close() {
        el.update();

        /* we can modify the player by indexing into it in the renderer's meshes */
        let player = &mut renderer.meshes[player_handle];
        player.color = vec3(0.5, 0.0, el.time.sin());
        move_player(&el, &mut player.position);
    
        renderer.camera.update(Vec3::ZERO, &el);
    
        let frame = el.ui.frame(&mut el.window);
        frame.text("hello, world! this is imgui");

        unsafe {
            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
            ClearColor(0.1, 0.2, 0.3, 1.0);
            
            renderer.draw();
            el.ui.draw();
        }
    }
}

examples/ik.rs (line 95)

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

    unsafe {
        Enable(DEPTH_TEST);
    }

    /* default projection type is perspective */
    renderer.camera.set_projection(ProjectionType::Orthographic);
    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
        .unwrap();

    /* we'll represent our player using a quad */
    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
        .unwrap();

    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything

    let mut segments = vec![];
    for _ in 0..128 {
        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);

        segments.push(new_segment);
    }

    renderer.meshes[segments[0].handle].hidden = true;
    renderer.meshes[segments[segments.len()-1].handle].hidden = true;

    renderer.meshes[player_handle].hidden = true;
    

    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);

    let mut clamped_pos;
    let mut player_vel;
    let mut old_pos = Vec3::ZERO;

    while !el.window.should_close() {
        el.update();
        renderer.update();
        
        segments.iter_mut().for_each(|s| {
            s.update(&mut renderer);
        });
        
        let player = &mut renderer.meshes[player_handle];
        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
        let clamped_player_pos = {
            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
            clamped_pos = player.position;

            vec3(clamped_pos.x, clamped_pos.y, 0.0)
        };
        fabrik(&mut segments, {
            if el.event_handler.lmb {
                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
            } else {
                clamped_player_pos
            }
        }, 0.0, 2);

        let first_segment_position = segments[0].pos;
        let seg_amm = segments.len() as f32;
        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
        let len = segments[0].length;
        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
        }

        player_vel = player.position - old_pos;
        old_pos = player.position;

        player.color = vec3(0.5, 0.0, el.time.sin());
        move_player(&el, &mut player.position);
    
        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);

        let frame = el.ui.frame(&mut el.window);
        frame.text("Hello, world! This is imgui.");
        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));

        unsafe {
            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
            ClearColor(0.1, 0.2, 0.3, 1.0);
            
            renderer.draw();
            el.ui.draw();
        }
    }
}