mitchellhansen/minimum-viable-game-engine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

halfway through imgui, the context is really not ergonomic

Browse Source
This commit is contained in:
mitchellhansen
2021-02-14 18:07:26 -08:00
parent 60ab3bebd8
commit 2370ce4974
6 changed files with 209 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Cargo.toml
View File

@@ -15,7 +15,7 @@ typed-arena = "2.0.1"
serde = { version = "1", features = ["derive"], optional = true }
log = "0.4"
png = "0.16"
winit = { version = "0.22.1", features = ["web-sys"] }
winit = "0.24.0"
rand = { version = "0.7.2", features = ["wasm-bindgen"] }
bytemuck = "1"
noise = "0.6"
@@ -30,3 +30,6 @@ rapier3d = { version = "0.5.0", features = ["simd-nightly", "parallel"] }
nalgebra = "0.24.1"
legion = "0.3.1"
wgpu = "0.7.0"
imgui = "0.7.0"
imgui-wgpu = "0.14.0"
imgui-winit-support = "0.7.0"

13
src/camera.rs
View File

@@ -136,16 +136,14 @@ impl CameraController {
pub fn update_camera(&mut self, camera: &mut Camera, dt: f32) {
// Move forward/backward and left/right
let (yaw_sin, yaw_cos) = camera.yaw.0.sin_cos();
let forward = Vector3::new(yaw_cos, 0.0, yaw_sin).normalize();
let right = Vector3::new(-yaw_sin, 0.0, yaw_cos).normalize();
let view_vector = Vector3::new(
(1.0 * camera.pitch.0.sin() * camera.yaw.0.sin()),
(1.0 * camera.pitch.0.cos()),
(1.0 * camera.pitch.0.sin() * camera.yaw.0.cos()),
);
// Offset the yaw 90 degrees and set the pitch to level for our
// right / left hand translation vectors
let offset = camera.yaw.0 + PI/2.0;
let pitch = PI/2.0;
let left_vector = Vector3::new(
@@ -156,19 +154,12 @@ impl CameraController {
camera.position += view_vector * (self.amount_forward - self.amount_backward) * self.speed * dt;
camera.position += left_vector * (self.amount_left - self.amount_right) * self.speed * dt;
// Move up/down. Since we don't use roll, we can just
// modify the y coordinate directly.
camera.position.y += (self.amount_up - self.amount_down) * self.speed * dt;
// Rotate
camera.yaw += Rad(self.rotate_horizontal) * self.sensitivity * dt;
camera.pitch += Rad(self.rotate_vertical) * self.sensitivity * dt;
// If process_mouse isn't called every frame, these values
// will not get set to zero, and the camera will rotate
// when moving in a non cardinal direction.
self.rotate_horizontal = 0.0;
self.rotate_vertical = 0.0;

13
src/geometry.rs
View File

@@ -62,16 +62,3 @@ pub fn import_mesh(mesh_path: &str) -> (Vec<Vertex>, Vec<u32>) {
(vertex_data.to_vec(), index_data.to_vec())
}
pub fn create_plane(size: f32) -> (Vec<Vertex>, Vec<u32>) {
let vertex_data = [
vertex([size, -size, 0.0], [0.0, 0.0, 1.0]),
vertex([size, size, 0.0], [0.0, 0.0, 1.0]),
vertex([-size, -size, 0.0], [0.0, 0.0, 1.0]),
vertex([-size, size, 0.0], [0.0, 0.0, 1.0]),
];
let index_data: &[u32] = &[0, 1, 2, 2, 1, 3];
(vertex_data.to_vec(), index_data.to_vec())
}

147
src/main.rs
View File

@@ -1,3 +1,6 @@
extern crate imgui;
extern crate imgui_wgpu;
extern crate imgui_winit_support;
extern crate tobj;
extern crate winit;
@@ -8,9 +11,17 @@ use std::sync::Arc;
use std::time::{Duration, Instant};
use bytemuck::__core::ops::Range;
use cgmath::{Decomposed, Deg, Euler, InnerSpace, Quaternion, Rotation3, SquareMatrix, Point3, Rad};
use cgmath::{
Decomposed, Deg, Euler, InnerSpace, Point3, Quaternion, Rad, Rotation3, SquareMatrix,
};
use futures::executor::block_on;
use futures::task::LocalSpawn;
use gilrs::{Gamepad, Gilrs};
use gilrs::Event as GilEvent;
use imgui::*;
use imgui_wgpu::{Renderer as ImguiRenderer, RendererConfig as ImguiRendererConfig};
use legion::*;
use rapier3d::counters::Timer;
use rapier3d::dynamics::{
IntegrationParameters, JointSet, RigidBody, RigidBodyBuilder, RigidBodyHandle, RigidBodySet,
};
@@ -20,30 +31,27 @@ use rapier3d::na::{Isometry, Isometry3, Vector, Vector3};
use rapier3d::pipeline::PhysicsPipeline;
use wgpu::{BindGroup, Buffer, TextureView};
use wgpu_subscriber;
use winit::event::DeviceEvent::MouseMotion;
use winit::platform::unix::x11::ffi::Time;
use winit::{
event::{self, WindowEvent},
event_loop::{ControlFlow, EventLoop},
};
use winit::event::DeviceEvent::MouseMotion;
use winit::platform::unix::x11::ffi::Time;
use winit::window::Window;
use gilrs::Event as GilEvent;
use crate::camera::{CameraController, Camera};
use crate::components::{Collider, Color, Physics, Position, LoopState};
use crate::camera::{Camera, CameraController};
use crate::components::{Collider, Color, LoopState, Physics, Position};
use crate::owned_event::{OwnedEvent, OwnedEventExtension};
use crate::physics::PhysicsState;
use crate::render::Renderer;
use crate::owned_event::{OwnedEventExtension, OwnedEvent};
use gilrs::{Gamepad, Gilrs};
use rapier3d::counters::Timer;
mod camera;
mod components;
mod geometry;
mod light;
mod owned_event;
mod physics;
mod render;
mod owned_event;
/*
@@ -104,38 +112,36 @@ fn main() {
let mut builder = winit::window::WindowBuilder::new();
builder = builder.with_title("MVGE");
// I don't know what they are doing here
#[cfg(windows_OFF)] // TODO
{
use winit::platform::windows::WindowBuilderExtWindows;
builder = builder.with_no_redirection_bitmap(true);
}
let window = builder.build(&event_loop).unwrap();
// Load up the renderer (and the resources)
let mut renderer = {
let mut renderer = render::Renderer::init(&window);
entity_loading(&mut world, &mut renderer);
renderer
};
let mut resources = Resources::default();
resources.insert(renderer);
let (physics_state, physics_pipeline) =
PhysicsState::build(rapier3d::math::Vector::new(0.0, -9.81, 0.05));
resources.insert(physics_state);
resources.insert(physics_pipeline);
// Load up all the resources
{
resources.insert(LoopState {
delta_time: Default::default(),
start_time: Instant::now(),
step_size: 0.01666, // 60hz
});
// The renderer
let mut renderer = render::Renderer::init(&window, &mut imgui_context);
entity_loading(&mut world, &mut renderer);
resources.insert(renderer);
resources.insert(window);
// Physics
let (physics_state, physics_pipeline) =
PhysicsState::build(rapier3d::math::Vector::new(0.0, -9.81, 0.05));
resources.insert(physics_state);
resources.insert(physics_pipeline);
resources.insert(Vec::<OwnedEvent<OwnedEventExtension>>::new());
// Loop data
resources.insert(LoopState {
delta_time: Default::default(),
start_time: Instant::now(),
step_size: 0.01666, // 60hz
});
// And our event stack
resources.insert(Vec::<OwnedEvent<OwnedEventExtension>>::new());
};
let event_loop_proxy = event_loop.create_proxy();
@@ -147,7 +153,12 @@ fn main() {
if gamepad_.name() == "PS4" {
gamepad = Some(gamepad_);
}
println!("{} is {:?} {:?}", gamepad_.name(), gamepad_.power_info(), gamepad_.id());
println!(
"{} is {:?} {:?}",
gamepad_.name(),
gamepad_.power_info(),
gamepad_.id()
);
}
let mut active_gamepad = None;
@@ -155,9 +166,11 @@ fn main() {
while let Some(GilEvent { id, event, time }) = gilrs.next_event() {
println!("{:?} New event from {}: {:?}", time, id, event);
active_gamepad = Some(id);
event_loop_proxy.send_event(OwnedEventExtension::GamepadEvent {
gil_event: GilEvent { id, event, time }
}).ok();
event_loop_proxy
.send_event(OwnedEventExtension::GamepadEvent {
gil_event: GilEvent { id, event, time },
})
.ok();
}
// // You can also use cached gamepad state
@@ -171,29 +184,35 @@ fn main() {
}
});
let mut elapsed_time: f32 = { // deltatime since last frame
let mut elapsed_time: f32 = {
// deltatime since last frame
let loop_state = resources.get::<LoopState>().unwrap();
loop_state.start_time.elapsed()
}.as_secs_f32();
}
.as_secs_f32();
let mut delta_time: f32 = 0.0;
let mut accumulator_time: f32 = 0.0;
let mut current_time: f32 = elapsed_time;
event_loop.run(move |event, _, control_flow| {
*control_flow = ControlFlow::Poll;
match event {
event::Event::NewEvents(cause) => {
event_schedule.execute(&mut world, &mut resources);
resources.get_mut::<Vec<OwnedEvent<OwnedEventExtension>>>()
.unwrap().clear();
resources
.get_mut::<Vec<OwnedEvent<OwnedEventExtension>>>()
.unwrap()
.clear();
}
event::Event::MainEventsCleared => {
let (step_size, elapsed_time) = { // deltatime since last frame
let (step_size, elapsed_time) = {
// deltatime since last frame
let loop_state = resources.get::<LoopState>().unwrap();
(loop_state.step_size, loop_state.start_time.elapsed().as_secs_f32())
(
loop_state.step_size,
loop_state.start_time.elapsed().as_secs_f32(),
)
};
delta_time = elapsed_time - current_time;
current_time = elapsed_time;
@@ -225,9 +244,10 @@ fn main() {
.unwrap()
.resize(width, height);
}
event::Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => {
*control_flow = ControlFlow::Exit
}
event::Event::WindowEvent {
event: WindowEvent::CloseRequested,
..
} => *control_flow = ControlFlow::Exit,
event::Event::RedrawRequested(_) => {
// Call the render system
render_schedule.execute(&mut world, &mut resources);
@@ -235,11 +255,14 @@ fn main() {
_ => {}
}
resources.get_mut::<Vec<OwnedEvent<OwnedEventExtension>>>()
.unwrap().push(event.into());
resources
.get_mut::<Vec<OwnedEvent<OwnedEventExtension>>>()
.unwrap()
.push(event.into());
});
}
pub fn entity_loading(world: &mut World, renderer: &mut Renderer) {
let monkey_mesh = renderer.load_mesh_to_buffer("./resources/monkey.obj");
@@ -248,10 +271,10 @@ pub fn entity_loading(world: &mut World, renderer: &mut Renderer) {
position: Point3 {
x: 0.0,
y: 0.0,
z: 10.0
z: 10.0,
},
yaw: Rad(-PI),
pitch: Rad(PI/2.0)
pitch: Rad(PI / 2.0),
},
Color {
r: 1.0,
@@ -272,8 +295,8 @@ pub fn entity_loading(world: &mut World, renderer: &mut Renderer) {
rot: Euler {
x: Deg(0.0),
y: Deg(-25.0),
z: Deg(0.0)
}
z: Deg(0.0),
},
},
Color {
r: 1.0,
@@ -323,17 +346,11 @@ pub fn entity_loading(world: &mut World, renderer: &mut Renderer) {
));
let mut dynamic_ball_body = RigidBodyBuilder::new_dynamic()
.position(Isometry3::new(
Vector3::new(0.0, 0.0, 0.0),
Vector::y(),
))
.position(Isometry3::new(Vector3::new(0.0, 0.0, 0.0), Vector::y()))
.build();
let mut static_floor_body = RigidBodyBuilder::new_static()
.position(Isometry3::new(
Vector3::new(0.0, -8.0, 0.0),
Vector::y(),
))
.position(Isometry3::new(Vector3::new(0.0, -8.0, 0.0), Vector::y()))
.build();
let ball_collider = ColliderBuilder::ball(1.5).build();

14
src/physics.rs
View File

@@ -96,6 +96,20 @@ pub fn update_camera(world: &mut SubWorld, #[resource] loop_state: &mut LoopStat
}
}
#[system]
#[write_component(Camera)]
pub fn update_imgui(
world: &mut SubWorld,
#[resource] loop_state: &mut LoopState,
#[resource] renderer: &mut Renderer,
) {
let mut query = <(&mut Camera, &mut CameraController)>::query();
for (mut camera, controller) in query.iter_mut(world) {
controller.update_camera(&mut camera, loop_state.step_size)
}
}
#[system]
#[write_component(Collider)]
#[write_component(Physics)]

109
src/render.rs
View File

@@ -23,8 +23,12 @@ use winit::window::Window;
use crate::camera::{Camera, CameraController};
use crate::components::{Color, Mesh, Position, RangeCopy};
use crate::geometry::{create_plane, import_mesh, vertex, Vertex};
use crate::geometry::{import_mesh, vertex, Vertex};
use crate::light::{DirectionalLight, LightRaw};
use imgui_winit_support::WinitPlatform;
use imgui::*;
use imgui_wgpu::{Renderer as ImguiRenderer, RendererConfig as ImguiRendererConfig};
use std::cell::RefCell;
#[cfg_attr(rustfmt, rustfmt_skip)]
#[allow(unused)]
@@ -80,7 +84,12 @@ pub struct Pass {
#[write_component(Mesh)]
#[write_component(Color)]
#[write_component(DirectionalLight)]
pub fn render_test(world: &mut SubWorld, #[resource] renderer: &mut Renderer) {
pub fn render_test(
world: &mut SubWorld,
#[resource] renderer: &mut Renderer,
#[resource] winit_window: &mut Window,
) {
let mut encoder = renderer
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
@@ -88,6 +97,92 @@ pub fn render_test(world: &mut SubWorld, #[resource] renderer: &mut Renderer) {
let frame = renderer.get_current_frame();
// set up imgui for rendering
// update delta time and prepare the frame
//renderer.imgui_platform.io_mut().update_delta_time(now - last_frame);
{
let mut imgui_context = imgui::Context::create();
imgui_context.set_ini_filename(None);
let font_size = 10.0 as f32;
//imgui_context.io_mut().font_global_scale = 10.0 as f32;
imgui_context.fonts().add_font(&[FontSource::DefaultFontData {
config: Some(imgui::FontConfig {
oversample_h: 1,
pixel_snap_h: true,
size_pixels: font_size,
..Default::default()
}),
}]);
// The imgui context lives as a resource for the render system to use
let mut platform = imgui_winit_support::WinitPlatform::init(imgui_context);
platform.attach_window(
imgui_context.io_mut(),
window,
imgui_winit_support::HiDpiMode::Default,
);
let clear_color = wgpu::Color {
r: 0.1,
g: 0.2,
b: 0.3,
a: 1.0,
};
let renderer_config = ImguiRendererConfig {
texture_format: sc_desc.format,
..Default::default()
};
let mut renderer = ImguiRenderer::new(imgui_context, &device, &queue, renderer_config);
renderer.imgui_platform
.prepare_frame(imgui_context.io_mut(), &winit_window)
.expect("Failed to prepare frame");
// get the frame and build a ui window
let ui = imgui_context.frame();
let window = imgui::Window::new(im_str!("Hello too"));
window
.size([400.0, 200.0], Condition::FirstUseEver)
.position([400.0, 200.0], Condition::FirstUseEver)
.build(&ui, || {
ui.text(im_str!("Frametime: {:?}", 10.0));
});
//ui.show_demo_window(&mut demo_open);
renderer.imgui_platform.prepare_render(&ui, &winit_window);
let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: None,
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.output.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
r: 0.1,
g: 0.2,
b: 0.3,
a: 1.0,
}),
store: true,
},
}],
depth_stencil_attachment: None,
});
renderer.imgui_renderer
.render(ui.render(), &renderer.queue, &renderer.device, &mut rpass)
.expect("Rendering failed");
drop(rpass);
}
// Update the camera uniform buffers, need to make it support selection of
// cameras
let mut query = <(&mut Camera)>::query();
@@ -253,6 +348,10 @@ pub struct Renderer {
light_uniform_buf: wgpu::Buffer,
camera_projection: Matrix4<f32>,
imgui_platform: WinitPlatform,
imgui_renderer: ImguiRenderer,
}
impl Renderer {
@@ -393,7 +492,8 @@ impl Renderer {
}
}
pub fn init(window: &Window) -> Renderer {
pub fn init(window: &Window, imgui_context: &mut imgui::Context) -> Renderer {
// Grab the GPU instance, and query its features
let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
let (size, surface) = unsafe {
@@ -804,6 +904,7 @@ impl Renderer {
label: Some("Depth Texture"),
});
Renderer {
swapchain: swap_chain,
queue: queue,
@@ -821,6 +922,8 @@ impl Renderer {
instance: Arc::new(instance),
views_given: 0,
camera_projection: mx_projection,
imgui_platform: platform,
imgui_renderer: renderer
}
}