feat(render): draw passes

1 files changed, 229 insertions, 0 deletions

diff --git a/examples/render-quad/src/main.rs b/examples/render-quad/src/main.rs
new file mode 100644
index 0000000..b16c3d0
--- /dev/null
+++ b/examples/render-quad/src/main.rs
@@ -0,0 +1,229 @@
+//! Renders ./example.bsp geometry: (), texture_idx: ()  geometry: (), texture_idx: ()
+
+#[macro_use]
+extern crate stockton_input_codegen;
+
+#[macro_use]
+extern crate legion;
+
+use anyhow::{Context, Result};
+use log::warn;
+use std::collections::BTreeMap;
+
+use std::sync::{Arc, RwLock};
+use stockton_levels::parts::data::{Geometry, Vertex};
+use stockton_levels::types::Rgba;
+use stockton_render::draw::LevelDrawPass;
+use winit::{event::Event, event_loop::EventLoop, window::WindowBuilder};
+
+use egui::{containers::CentralPanel, Frame};
+use stockton_contrib::delta_time::*;
+use stockton_contrib::flycam::*;
+
+use stockton_input::{Axis, InputManager, Mouse};
+
+use stockton_render::error::full_error_display;
+use stockton_render::systems::*;
+use stockton_render::{Renderer, UiState, WindowEvent};
+
+use stockton_types::components::{CameraSettings, CameraVPMatrix, Transform};
+use stockton_types::{Session, Vector2, Vector3};
+
+mod level;
+use level::*;
+
+type Dp<'a> = LevelDrawPass<'a, DemoLevel>;
+
+#[derive(InputManager, Default, Clone, Debug)]
+struct MovementInputs {
+    #[axis]
+    x: Axis,
+
+    #[axis]
+    y: Axis,
+
+    #[axis]
+    z: Axis,
+}
+
+impl FlycamInput for MovementInputs {
+    fn get_x_axis(&self) -> &Axis {
+        &self.x
+    }
+    fn get_y_axis(&self) -> &Axis {
+        &self.y
+    }
+    fn get_z_axis(&self) -> &Axis {
+        &self.z
+    }
+}
+
+#[system]
+fn hello_world(#[resource] ui: &mut UiState) {
+    CentralPanel::default()
+        .frame(Frame::none())
+        .show(ui.ctx(), |ui| {
+            ui.heading("Hello, World!");
+        });
+}
+
+fn main() {
+    if let Err(err) = try_main() {
+        eprintln!("{}", full_error_display(err));
+    }
+}
+
+fn try_main<'a>() -> Result<()> {
+    // Initialise logger
+    simplelog::TermLogger::init(
+        log::LevelFilter::Debug,
+        simplelog::ConfigBuilder::new()
+            .set_max_level(log::LevelFilter::Debug)
+            .set_thread_mode(simplelog::ThreadLogMode::Names)
+            .build(),
+        simplelog::TerminalMode::Stderr,
+        simplelog::ColorChoice::Auto,
+    )
+    .context("Error initialising logger")?;
+
+    // Make a window
+    let event_loop = EventLoop::new();
+    let window = WindowBuilder::new()
+        .build(&event_loop)
+        .context("Error creating window")?;
+
+    if window.set_cursor_grab(true).is_err() {
+        warn!("warning: cursor not grabbed");
+    }
+    window.set_cursor_visible(false);
+
+    // TODO: Parse the map file
+    let map = Arc::new(RwLock::new(DemoLevel {
+        faces: vec![Face {
+            geometry: Geometry::Vertices(
+                Vertex {
+                    position: Vector3::new(-128.0, 128.0, 128.0),
+                    tex: Vector2::new(0.0, 0.0),
+                    color: Rgba::from_slice(&[0, 0, 0, 1]),
+                },
+                Vertex {
+                    position: Vector3::new(-128.0, -128.0, 128.0),
+                    tex: Vector2::new(0.0, 1.0),
+                    color: Rgba::from_slice(&[0, 0, 0, 1]),
+                },
+                Vertex {
+                    position: Vector3::new(128.0, 128.0, 128.0),
+                    tex: Vector2::new(1.0, 0.0),
+                    color: Rgba::from_slice(&[0, 0, 0, 1]),
+                },
+            ),
+            texture_idx: 0,
+        }]
+        .into_boxed_slice(),
+        textures: vec![Texture {
+            name: "example_texture".to_string(),
+        }]
+        .into_boxed_slice(),
+    }));
+
+    // Create the UI State
+    let mut ui = UiState::new();
+
+    // Create the input manager
+    let manager = {
+        use stockton_input::InputMutation::*;
+        use MovementInputsFields::*;
+
+        let mut actions = BTreeMap::new();
+
+        actions.insert(17, (Z, PositiveAxis)); // W
+        actions.insert(30, (X, NegativeAxis)); // A
+        actions.insert(31, (Z, NegativeAxis)); // S
+        actions.insert(32, (X, PositiveAxis)); // D
+        actions.insert(29, (Y, NegativeAxis)); // Ctrl
+        actions.insert(57, (Y, PositiveAxis)); // Space
+
+        MovementInputsManager::new(actions)
+    };
+
+    let ratio = window.inner_size().width as f32 / window.inner_size().height as f32;
+
+    // Load everything into the session
+    let mut session = Session::new(
+        move |resources| {
+            resources.insert(map);
+            resources.insert(manager);
+            resources.insert(Timing::default());
+            resources.insert(Mouse::default());
+        },
+        move |schedule| {
+            schedule
+                .add_system(update_deltatime_system())
+                .add_system(process_window_events_system::<
+                    MovementInputsManager,
+                    Dp<'static>,
+                >())
+                .flush()
+                .add_system(hello_world_system())
+                .add_system(flycam_move_system::<MovementInputsManager>())
+                .flush()
+                .add_thread_local(calc_vp_matrix_system(ratio));
+        },
+    );
+
+    // Add our player entity
+    let player = session.world.push((
+        Transform {
+            position: Vector3::new(0.0, 0.0, 0.0),
+            rotation: Vector3::new(0.0, 0.0, 0.0),
+        },
+        CameraSettings {
+            far: 1024.0,
+            fov: 90.0,
+            near: 0.1,
+        },
+        CameraVPMatrix::default(),
+        FlycamControlled::new(512.0, 400.0),
+    ));
+
+    // Create the renderer
+    let (renderer, tx): (Renderer<Dp<'static>>, _) = Renderer::new(&window, &session, player)?;
+    let new_control_flow = renderer.update_control_flow.clone();
+
+    // Populate the initial UI state
+    ui.populate_initial_state(&renderer);
+
+    session.resources.insert(renderer);
+    session.resources.insert(ui);
+
+    // Done loading - This is our main loop.
+    // It just communicates events to the session and continuously ticks
+    event_loop.run(move |event, _, flow| {
+        match event {
+            Event::MainEventsCleared => {
+                window.request_redraw();
+            }
+            Event::RedrawRequested(_) => {
+                session.do_update();
+                let mut renderer = session
+                    .resources
+                    .get_mut::<Renderer<Dp<'static>>>()
+                    .unwrap();
+                renderer.render(&session).unwrap();
+            }
+            _ => {
+                if let Some(we) = WindowEvent::from(&event) {
+                    tx.send(we).unwrap()
+                }
+            }
+        }
+
+        // Update the control flow if the session has requested it.
+        {
+            let new_control_flow = new_control_flow.read().unwrap();
+            if *new_control_flow != *flow {
+                *flow = *new_control_flow;
+            }
+        };
+    });
+}