vox/src/main.rs

#![feature(const_fn_trait_bound)]

#[macro_use]
extern crate glium;

use glium::{
    glutin::{self, event::KeyboardInput},
    Surface,
};

use crate::particle_system::{generate_particle_vertexs, Particle};
pub mod chunk;
pub mod config;
pub mod coordinates;
pub mod particle_system;
pub mod textures;
pub mod vertex;
pub mod voxel;

fn main() {
    let _chunk = chunk::Chunk::half_chunk_filled();

    bruh();
}

mod teapot;

pub fn bruh() {
    let event_loop = glutin::event_loop::EventLoop::new();
    let wb = glutin::window::WindowBuilder::new()
        .with_title("Voxel Engine")
        .with_resizable(true)
        .with_transparent(true);
    let cb = glutin::ContextBuilder::new().with_depth_buffer(24);

    let display = glium::Display::new(wb, cb, &event_loop).unwrap();

    let vertex_shader_src = include_str!("../assets/shaders/teapot/teapot.vert");
    let fragment_shader_src = include_str!("../assets/shaders/teapot/teapot.frag");

    let teapot_program =
        glium::Program::from_source(&display, vertex_shader_src, fragment_shader_src, None)
            .unwrap();

    let solid_color_particles_vertex_shader_src =
        include_str!("../assets/shaders/particles/solid_color.vert");
    let solid_color_particles_fragment_shader_src =
        include_str!("../assets/shaders/particles/solid_color.frag");

    let solid_color_particles_program = glium::Program::from_source(
        &display,
        solid_color_particles_vertex_shader_src,
        solid_color_particles_fragment_shader_src,
        None,
    )
    .unwrap();

    let mut particles_vec: Vec<Particle> = Vec::new();
    for _ in 0..=10000 {
        particles_vec.push(Particle::random_particle());
    }
    let mut render_particles = true;
    event_loop.run(move |event, _, control_flow| {
        use glutin::event::Event::*;
        match event {
            WindowEvent { event, .. } => match event {
                glutin::event::WindowEvent::CloseRequested => {
                    *control_flow = glutin::event_loop::ControlFlow::Exit;
                    return;
                }
                _ => return,
            },

            NewEvents(cause) => {
                use glutin::event::StartCause::*;
                match cause {
                    ResumeTimeReached { .. } => (),
                    Init => (),
                    _ => return,
                }
            }
            DeviceEvent {
                device_id: _,
                event,
            } => match event {
                glutin::event::DeviceEvent::Key(key) => match key {
                    KeyboardInput {
                        virtual_keycode: Some(glutin::event::VirtualKeyCode::Escape),
                        ..
                    } => {
                        *control_flow = glutin::event_loop::ControlFlow::Exit;
                        return;
                    }
                    KeyboardInput {
                        state: glutin::event::ElementState::Pressed,
                        virtual_keycode,
                        ..
                    } => {
                        println!("{:?}", virtual_keycode);
                        render_particles = !render_particles;
                        return;
                    }
                    _ => return,
                },
                _ => return,
            },

            _ => {
                return;
            }
        }

        let next_frame_time =
            std::time::Instant::now() + std::time::Duration::from_nanos(16_666_667);
        *control_flow = glutin::event_loop::ControlFlow::WaitUntil(next_frame_time);

        let mut target = display.draw();

        target.clear_color_and_depth((0.0, 0.0, 1.0, 1.0), 1.0);

        if false {
            // Teapot stage

            let positions = glium::VertexBuffer::new(&display, &teapot::VERTICES).unwrap();
            let normals = glium::VertexBuffer::new(&display, &teapot::NORMALS).unwrap();
            let indices = glium::IndexBuffer::new(
                &display,
                glium::index::PrimitiveType::TrianglesList,
                &teapot::INDICES,
            )
            .unwrap();

            let matrix = [
                [0.01, 0.0, 0.0, 0.0],
                [0.0, 0.01, 0.0, 0.0],
                [0.0, 0.0, 0.01, 0.0],
                [0.0, 0.0, 0.0, 1.0f32],
            ];

            let light = [-1.0, 0.4, 0.9f32];

            let params = glium::DrawParameters {
                depth: glium::Depth {
                    test: glium::draw_parameters::DepthTest::IfLess,
                    write: true,
                    ..Default::default()
                },
                ..Default::default()
            };

            target
                .draw(
                    (&positions, &normals),
                    &indices,
                    &teapot_program,
                    &uniform! { matrix: matrix, u_light: light },
                    &params,
                )
                .unwrap();
        }

        {
            // Solid Voxel stage
            let particle_group_color: [f32; 4] = [1.0, 1.0, 1.0, 1.0];

            let shape = voxel::VoxelData::new(
                0,
                voxel::Light {
                    red: 0,
                    green: 0,
                    blue: 0,
                    sun: 0,
                },
            )
            .construct_vertexes(coordinates::Coordinates {
                x: 0.0,
                y: 0.0,
                z: 0.0,
            });

            let vertex_buffer = glium::VertexBuffer::new(&display, &shape).unwrap();

            let uniforms = uniform! {
                u_color: particle_group_color,
            };

            target
                .draw(
                    &vertex_buffer,
                    &glium::index::NoIndices(glium::index::PrimitiveType::TrianglesList),
                    &solid_color_particles_program,
                    &uniforms,
                    &Default::default(),
                )
                .unwrap();
        }

        if render_particles {
            // Particle Stage

            let particle_group_color: [f32; 4] = [1.0, 0.0, 1.0, 1.0];

            let shape = generate_particle_vertexs(&mut particles_vec);

            let vertex_buffer = glium::VertexBuffer::new(&display, &shape).unwrap();

            let uniforms = uniform! {
                u_color: particle_group_color,
            };

            target
                .draw(
                    &vertex_buffer,
                    &glium::index::NoIndices(glium::index::PrimitiveType::TrianglesList),
                    &solid_color_particles_program,
                    &uniforms,
                    &Default::default(),
                )
                .unwrap();
        }

        target.finish().unwrap();
    });
}