Struct tiny_game_framework::Renderer

pub struct Renderer {
    pub meshes: HashMap<String, Mesh>,
    pub instance_meshes: HashMap<String, InstanceMesh>,
}

Fields

meshes: HashMap<String, Mesh>

instance_meshes: HashMap<String, InstanceMesh>

Implementations

impl Renderer

pub fn new() -> Self

Examples found in repository

examples/rotation.rs (line 7)

fn main() {
    let resolution = vec2(500., 500.);
    let mut el = EventLoop::new(resolution.x as u32, resolution.y as u32);
    let mut renderer = Renderer::new();

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

        unsafe {
            renderer.draw(&el);
        }
    }
}

examples/test_scene.rs (line 7)

fn main() {
    let resolution = vec2(500., 500.);
    let mut el = EventLoop::new(resolution.x as u32, resolution.y as u32);
    let mut renderer = Renderer::new();

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

        unsafe {
            renderer.draw(&el);
        }
    }
}

examples/verlet_physics.rs (line 14)

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

    let mut world = World::new(&mut renderer);

    let mut dt = 0.0;
    while !el.window.should_close() {
        let now = std::time::Instant::now();
        el.update();

        world.update(&mut renderer, dt, &el);
        
        unsafe {
            gl::Clear(gl::COLOR_BUFFER_BIT);
            renderer.draw(&el);
        }

        dt = now.elapsed().as_secs_f32();
    }
}

pub unsafe fn draw(&self, el: &EventLoop)

Examples found in repository

examples/rotation.rs (line 13)

fn main() {
    let resolution = vec2(500., 500.);
    let mut el = EventLoop::new(resolution.x as u32, resolution.y as u32);
    let mut renderer = Renderer::new();

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

        unsafe {
            renderer.draw(&el);
        }
    }
}

examples/test_scene.rs (line 13)

fn main() {
    let resolution = vec2(500., 500.);
    let mut el = EventLoop::new(resolution.x as u32, resolution.y as u32);
    let mut renderer = Renderer::new();

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

        unsafe {
            renderer.draw(&el);
        }
    }
}

examples/verlet_physics.rs (line 27)

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

    let mut world = World::new(&mut renderer);

    let mut dt = 0.0;
    while !el.window.should_close() {
        let now = std::time::Instant::now();
        el.update();

        world.update(&mut renderer, dt, &el);
        
        unsafe {
            gl::Clear(gl::COLOR_BUFFER_BIT);
            renderer.draw(&el);
        }

        dt = now.elapsed().as_secs_f32();
    }
}

impl Renderer

pub fn add_mesh_from_vertices_and_indices( &mut self, name: &str, vertices: Vec<Vertex>, indices: Vec<u32> ) -> Result<(), String>

pub fn add_mesh(&mut self, name: &str, mesh: Mesh) -> Result<(), String>

pub fn get_mesh_mut(&mut self, name: &str) -> Option<&mut Mesh>

Examples found in repository

examples/verlet_physics.rs (line 129)

    pub fn new(p: Vec3, name: &str, renderer: &mut Renderer, radius: f32) -> Self {
        let n = Vec3::ZERO;

        let circle = Circle::new(7, radius / 250.0, vec4(rand_betw(0.0, 1.0), rand_betw(0.0, 1.0), rand_betw(0.0, 1.0), 1.0));
        circle.add_to_renderer(name, renderer);
        renderer.get_mesh_mut(name).unwrap().rotation = Quat::from_euler(EulerRot::XYZ, 0.0, 0.0, rand_betw(0.0, 2.0*std::f32::consts::PI));

        Self {
            p,
            op: p,
            v: n,

            r: radius,

            name: name.to_string(),
        }
    }

    pub fn update(&mut self, dt: f32) {
        self.v = self.p - self.op;
        self.op = self.p;
        self.p += self.v + GRAVITY * dt;
    }

    pub fn check_with(&self, particle: &Particle) -> bool {
        if self.p.distance(particle.p) < self.r * 2.0 {
            true
        } else {
            false
        }
    }

    pub fn constrain(&mut self, el: &EventLoop) {
        let (w, h) = el.window.get_framebuffer_size();
        let (hw, hh) = (w as f32 / 2.0, h as f32 / 2.0);

        if self.p.x >= hw - self.r || self.p.x <= -hw + self.r {
            self.p.x = self.p.x.clamp(-hw + self.r, hw - self.r);
            self.v.x = -self.v.x * 0.8;
            self.op.x = self.p.x - self.v.x;
        }

        if self.p.y >= hh - self.r || self.p.y <= -hh + self.r {
            self.p.y = self.p.y.clamp(-hh + self.r, hh - self.r);
            self.v.y = -self.v.y * 0.8;
            self.op.y = self.p.y - self.v.y;
        }
    }

    pub fn update_mesh(&self, renderer: &mut Renderer) {
        if let Some(mesh) = renderer.get_mesh_mut(&self.name) {
            mesh.position.x = lerp(mesh.position.x, self.p.x, 0.5);
            mesh.position.y = lerp(mesh.position.y, self.p.y, 0.5);
        }
    }

pub fn get_mesh(&self, name: &str) -> Option<&Mesh>

pub fn destroy_mesh(&mut self, name: &str) -> Result<(), String>

impl Renderer

pub fn add_instance_mesh( &mut self, name: &str, mesh: InstanceMesh ) -> Result<(), String>