482 lines
12 KiB
Rust
482 lines
12 KiB
Rust
use std::{
|
|
collections::HashMap,
|
|
};
|
|
|
|
use anyhow::Result;
|
|
use maplit::hashmap;
|
|
|
|
use opengl_rust::{
|
|
prelude::*,
|
|
gl_state::*,
|
|
physics::PhysicsBody,
|
|
renderable_model::{
|
|
attributes,
|
|
RenderableModel,
|
|
},
|
|
shader_closure::ShaderLookup,
|
|
texture::Texture,
|
|
};
|
|
|
|
mod uniforms {
|
|
use iota::iota;
|
|
iota! {
|
|
pub const
|
|
MVP: u32 = iota;
|
|
, OBJECT_SPACE_LIGHT
|
|
, OBJECT_SPACE_SKY
|
|
, ALBEDO
|
|
, MIN_ALBEDO
|
|
, MIN_BRIGHT
|
|
, TEXTURE
|
|
}
|
|
}
|
|
|
|
struct GameState {
|
|
player: PhysicsBody,
|
|
aabbs: Vec <opengl_rust::physics::Aabb>,
|
|
}
|
|
|
|
impl Default for GameState {
|
|
fn default () -> Self {
|
|
let player = Default::default ();
|
|
let aabbs = [
|
|
((-4.0, -4.0, -3.0), (4.0, 4.0, -1.0)),
|
|
((-1.5, 1.0, -1.0), (-0.5, 2.0, 0.0)),
|
|
((-0.5, 1.0, 0.0), (0.5, 2.0, 1.0)),
|
|
((0.5, 1.0, 1.0), (1.5, 2.0, 2.0)),
|
|
].into_iter ()
|
|
.map (|(min, max)| {
|
|
opengl_rust::physics::Aabb {
|
|
min: min.into (),
|
|
max: max.into (),
|
|
}
|
|
})
|
|
.collect ();
|
|
|
|
Self {
|
|
player,
|
|
aabbs,
|
|
}
|
|
}
|
|
}
|
|
|
|
struct GameGraphics {
|
|
passes: Vec <Pass>,
|
|
|
|
shaders: Vec <ShaderClosure>,
|
|
shader_lookup: HashMap <u32, usize>,
|
|
|
|
mesh_cube: RenderableModel,
|
|
mesh_sky: RenderableModel,
|
|
mesh_sphere: RenderableModel,
|
|
|
|
text_stream: TriangleStream,
|
|
|
|
texture_crate: Texture,
|
|
texture_earth: Texture,
|
|
texture_sky: Texture,
|
|
|
|
frames: u64,
|
|
}
|
|
|
|
impl ShaderLookup for GameGraphics {
|
|
fn lookup <'a> (&'a self, id: u32) -> &'a ShaderClosure {
|
|
&self.shaders [self.shader_lookup [&id]]
|
|
}
|
|
}
|
|
|
|
impl GameGraphics {
|
|
fn draw (
|
|
&self,
|
|
state: &GameState,
|
|
gl_state: &mut GlState,
|
|
) {
|
|
use uniforms as u;
|
|
|
|
let white = color_from_255 ((255.0, 255.0, 255.0));
|
|
let black = color_from_255 ((0.0, 0.0, 0.0));
|
|
let shadow_blue = color_from_255 ((0.0, 0.0, 0.25));
|
|
|
|
let screen_size = (320.0, 240.0);
|
|
|
|
let fov = 30.0f32;
|
|
|
|
let proj_mat = Mat4::perspective_rh_gl (fov.to_radians (), screen_size.0 / screen_size.1, 0.125, 200.0);
|
|
|
|
let view_mat = proj_mat *
|
|
Mat4::from_translation ((0.0, 0.0, -20.0).into ()) *
|
|
Mat4::from_rotation_x ((45.0 - 90.0f32).to_radians ())
|
|
;
|
|
let world_model_mat = Mat4::IDENTITY;
|
|
|
|
self.passes [0].with (gl_state, || {
|
|
glezz::clear_color (0.5f32, 0.5f32, 0.5f32, 1.0f32);
|
|
glezz::clear (gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT | gl::STENCIL_BUFFER_BIT);
|
|
});
|
|
|
|
self.passes [1].with_shader (gl_state, self, |shader_vars| {
|
|
let attrs = shader_vars.attrs;
|
|
let unis = shader_vars.unis;
|
|
|
|
self.texture_earth.bind ();
|
|
|
|
{
|
|
let mvp = view_mat *
|
|
Mat4::from_translation (state.player.pos) *
|
|
Mat4::from_scale ((0.5, 0.5, 0.5).into ());
|
|
glezz::uniform_matrix_4fv (unis [&u::MVP], &mvp);
|
|
glezz::uniform_3fv (unis [&u::ALBEDO], &white);
|
|
|
|
self.mesh_sphere.draw_all (attrs, |_| {
|
|
true
|
|
});
|
|
}
|
|
|
|
self.texture_crate.bind ();
|
|
glezz::uniform_3fv (unis [&u::ALBEDO], &white);
|
|
|
|
for aabb in &state.aabbs {
|
|
let min = aabb.min;
|
|
let max = aabb.max;
|
|
let center = (min + max) / 2.0;
|
|
let scale = (max - min) / 2.0;
|
|
|
|
let mvp = view_mat *
|
|
Mat4::from_translation (center) *
|
|
Mat4::from_scale (scale);
|
|
glezz::uniform_matrix_4fv (unis [&u::MVP], &mvp);
|
|
|
|
self.mesh_cube.draw_all (attrs, |_| {
|
|
true
|
|
});
|
|
}
|
|
|
|
glezz::uniform_3fv (unis [&u::ALBEDO], &shadow_blue);
|
|
|
|
if true {
|
|
// Raycast for player shadow
|
|
let coll = opengl_rust::physics::get_candidate (
|
|
&[], &state.aabbs,
|
|
state.player.pos,
|
|
state.player.pos + Vec3::new (0.0, 0.0, -100.0),
|
|
0.0
|
|
);
|
|
|
|
if coll.t <= 1.0 {
|
|
let mvp = view_mat *
|
|
Mat4::from_translation (coll.p_impact + Vec3::new (0.0, 0.0, 0.0625)) *
|
|
Mat4::from_scale ((0.5, 0.5, 0.0).into ());
|
|
glezz::uniform_matrix_4fv (unis [&u::MVP], &mvp);
|
|
|
|
self.mesh_sphere.draw_all (attrs, |_| {
|
|
true
|
|
});
|
|
}
|
|
|
|
for aabb in &state.aabbs {
|
|
// Raycast for box shadows
|
|
let min = aabb.min;
|
|
let max = aabb.max;
|
|
let center = (min + max) / 2.0;
|
|
let scale = (max - min) / 2.0;
|
|
|
|
let coll = opengl_rust::physics::get_candidate (
|
|
&[], &state.aabbs,
|
|
center,
|
|
center + Vec3::new (0.0, 0.0, -100.0),
|
|
0.0
|
|
);
|
|
|
|
if coll.t <= 1.0 {
|
|
let mvp = view_mat *
|
|
Mat4::from_translation (coll.p_impact + Vec3::new (0.0, 0.0, 0.0625)) *
|
|
Mat4::from_scale ((scale.x, scale.y, 0.0).into ());
|
|
glezz::uniform_matrix_4fv (unis [&u::MVP], &mvp);
|
|
|
|
self.mesh_cube.draw_all (attrs, |_| {
|
|
true
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
let sky_mvp_mat = view_mat * Mat4::from_scale ((64.0, 64.0, 64.0).into ());
|
|
|
|
self.texture_sky.bind ();
|
|
glezz::uniform_matrix_4fv (unis [&u::MVP], &sky_mvp_mat);
|
|
glezz::uniform_3fv (unis [&u::ALBEDO], &white);
|
|
glezz::uniform_3fv (unis [&u::MIN_BRIGHT], &white);
|
|
glezz::uniform_3fv (unis [&u::MIN_ALBEDO], &black);
|
|
glezz::uniform_1i (unis [&u::TEXTURE], 0);
|
|
|
|
// self.mesh_sky.draw_all (attrs, |_| true);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main () -> Result <()> {
|
|
tracing_subscriber::fmt::fmt ()
|
|
.with_env_filter (tracing_subscriber::EnvFilter::from_default_env())
|
|
.with_span_events (tracing_subscriber::fmt::format::FmtSpan::CLOSE)
|
|
.init ();
|
|
|
|
let sdl_context = sdl2::init ().map_err (|e| anyhow! ("Can't init SDL: {}", e))?;
|
|
let video_subsystem = sdl_context.video ().map_err (|e| anyhow! ("Can't get SDL video subsystem: {}", e))?;
|
|
let window = video_subsystem.window ("3D platformer", 320, 240)
|
|
.position_centered ()
|
|
.opengl ()
|
|
.build ()
|
|
?;
|
|
|
|
gl::load_with (|s| {
|
|
video_subsystem.gl_get_proc_address (s) as *const _
|
|
});
|
|
|
|
if ! gl::ClearColor::is_loaded () {
|
|
bail! ("gl::ClearColor didn't load, something is wrong with OpenGL");
|
|
}
|
|
|
|
let gl_ctx = window.gl_create_context ().map_err (|e| anyhow! ("Can't create OpenGL context: {}", e))?;
|
|
|
|
window.gl_make_current (&gl_ctx).map_err (|e| anyhow! ("Can't make OpenGL context current: {}", e))?;
|
|
|
|
let mut event_pump = sdl_context.event_pump ().unwrap ();
|
|
|
|
let mut time_step = TimeStep::new (60, 1000);
|
|
let mut graphics_frames = 0;
|
|
|
|
let uniform_names = {
|
|
vec! [
|
|
(uniforms::MVP, "uni_mvp"),
|
|
(uniforms::OBJECT_SPACE_LIGHT, "uni_object_space_light"),
|
|
(uniforms::OBJECT_SPACE_SKY, "uni_object_space_sky"),
|
|
(uniforms::ALBEDO, "uni_albedo"),
|
|
(uniforms::MIN_ALBEDO, "uni_min_albedo"),
|
|
(uniforms::MIN_BRIGHT, "uni_min_bright"),
|
|
(uniforms::TEXTURE, "uni_texture"),
|
|
]
|
|
};
|
|
|
|
let attr_names = {
|
|
vec! [
|
|
(attributes::POS, "attr_pos"),
|
|
(attributes::UV, "attr_uv"),
|
|
(attributes::NORMAL, "attr_normal"),
|
|
]
|
|
};
|
|
|
|
let shaders: Vec <_> = [
|
|
("shaders/pumpkin-vert.glsl", "shaders/pumpkin-frag.glsl"),
|
|
("shaders/shadow-vert.glsl", "shaders/shadow-frag.glsl"),
|
|
("shaders/terrain-vert.glsl", "shaders/terrain-frag.glsl"),
|
|
].into_iter ()
|
|
.map (|(v, f)| {
|
|
ShaderClosure::new (shader_from_files (v, f), &uniform_names, &attr_names)
|
|
})
|
|
.collect ();
|
|
|
|
let mesh_cube = renderable_from_iqm_file ("cube.iqm");
|
|
let mesh_sky = renderable_from_iqm_file ("sky-sphere.iqm");
|
|
let mesh_sphere = renderable_from_iqm_file ("sphere.iqm");
|
|
|
|
let passes = vec![
|
|
// Clear everything
|
|
Pass::default ()
|
|
.color_mask ([1, 1, 1, 1])
|
|
.depth_mask (1)
|
|
.clone (),
|
|
// Draw world
|
|
Pass::default ()
|
|
.shader (&shaders [0])
|
|
.flags ([
|
|
(gl::CULL_FACE, true),
|
|
(gl::DEPTH_TEST, true),
|
|
(gl::TEXTURE_2D, true),
|
|
(gl::STENCIL_TEST, false),
|
|
].into_iter ())
|
|
.front_face (FrontFace::Ccw)
|
|
.color_mask ([1, 1, 1, 1])
|
|
.depth_mask (1)
|
|
.clone (),
|
|
];
|
|
|
|
let text_stream = TriangleStream {
|
|
verts: gpu_buffers::VertexBuffer::streaming (4 * 5 * 6 * 1024),
|
|
indices: {
|
|
let quad = [
|
|
0, 1, 2,
|
|
0, 2, 3,
|
|
];
|
|
|
|
let v: Vec <u32> = (0u32..1024).map (|i| {
|
|
quad.iter ().map (move |j| 4 * i + j)
|
|
}).flatten ().collect ();
|
|
gpu_buffers::IndexBuffer::from_slice_u32 (&v)
|
|
}
|
|
};
|
|
|
|
let shader_lookup = HashMap::from_iter (shaders.iter ().enumerate ()
|
|
.map (|(i, s)| {
|
|
(s.get_id (), i)
|
|
}));
|
|
|
|
shaders [0].with (None, |shader_vars| {
|
|
let attrs = shader_vars.attrs;
|
|
glezz::enable_vertex_attrib_array (attrs [attributes::POS]);
|
|
glezz::enable_vertex_attrib_array (attrs [attributes::UV]);
|
|
glezz::enable_vertex_attrib_array (attrs [attributes::NORMAL]);
|
|
});
|
|
|
|
let mut graphics = GameGraphics {
|
|
mesh_cube,
|
|
mesh_sky,
|
|
mesh_sphere,
|
|
passes,
|
|
shader_lookup,
|
|
shaders,
|
|
text_stream,
|
|
texture_crate: Texture::from_file ("crate.png"),
|
|
texture_earth: Texture::from_file ("earth.png"),
|
|
texture_sky: Texture::from_file ("sky.png"),
|
|
frames: 0,
|
|
};
|
|
|
|
let mut gl_state = Default::default ();
|
|
let mut game_state = GameState::default ();
|
|
let phys_params = opengl_rust::physics::Params {
|
|
dt: 1.0 / 60.0,
|
|
gravity: (0.0, 0.0, -0.25).into (),
|
|
margin: 0.00125,
|
|
};
|
|
|
|
let player_speed = 2.0;
|
|
let player_jump_speed = 8.0;
|
|
let mut player_jump_vec: Option <Vec3> = None;
|
|
|
|
'running: loop {
|
|
let _frames_to_do = time_step.step ();
|
|
let mut player_wants_to_jump = false;
|
|
|
|
for event in event_pump.poll_iter () {
|
|
match event {
|
|
Event::Quit {..} |
|
|
Event::KeyDown { keycode: Some (Keycode::Escape), .. } => {
|
|
break 'running
|
|
},
|
|
Event::KeyDown { keycode: Some (Keycode::R), .. } => {
|
|
game_state = Default::default ();
|
|
},
|
|
Event::KeyDown { keycode: Some (Keycode::Space), .. } => {
|
|
player_wants_to_jump = true;
|
|
},
|
|
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
let kb_state = event_pump.keyboard_state ();
|
|
|
|
let player_speed = if player_jump_vec.is_some () {
|
|
game_state.player.vel.x = 0.0;
|
|
game_state.player.vel.y = 0.0;
|
|
player_speed
|
|
}
|
|
else {
|
|
0.125
|
|
};
|
|
|
|
if kb_state.is_scancode_pressed (Scancode::Left) {
|
|
game_state.player.vel.x -= player_speed;
|
|
}
|
|
if kb_state.is_scancode_pressed (Scancode::Right) {
|
|
game_state.player.vel.x += player_speed;
|
|
}
|
|
if kb_state.is_scancode_pressed (Scancode::Up) {
|
|
game_state.player.vel.y += player_speed;
|
|
}
|
|
if kb_state.is_scancode_pressed (Scancode::Down) {
|
|
game_state.player.vel.y -= player_speed;
|
|
}
|
|
|
|
if player_wants_to_jump {
|
|
if let Some (normal) = player_jump_vec.clone () {
|
|
game_state.player.vel += normal * player_jump_speed;
|
|
}
|
|
}
|
|
|
|
let phys_result = opengl_rust::physics::step (&phys_params, &[], &game_state.aabbs, 0.5, &game_state.player);
|
|
|
|
game_state.player = phys_result.body;
|
|
// tracing::debug! ("player pos: {}", game_state.player.pos);
|
|
dbg! (player_jump_vec);
|
|
|
|
player_jump_vec = None;
|
|
for normal in &phys_result.normals_hit {
|
|
player_jump_vec = Some (match player_jump_vec {
|
|
None => *normal,
|
|
Some (old) => {
|
|
if normal.z > old.z {
|
|
*normal
|
|
}
|
|
else {
|
|
old
|
|
}
|
|
},
|
|
});
|
|
}
|
|
|
|
window.gl_make_current (&gl_ctx).unwrap ();
|
|
|
|
graphics.draw (&game_state, &mut gl_state);
|
|
graphics.frames += 1;
|
|
|
|
window.gl_swap_window ();
|
|
|
|
tokio::time::sleep (Duration::from_millis (15)).await;
|
|
}
|
|
|
|
Ok (())
|
|
}
|
|
|
|
struct ShaderLocations {
|
|
attr_pos: u32,
|
|
attr_normal: u32,
|
|
attr_color: u32,
|
|
uni_mvp: i32,
|
|
}
|
|
|
|
impl ShaderLocations {
|
|
pub fn new (shader_program: &opengl_rust::shader::ShaderProgram) -> anyhow::Result <Self>
|
|
{
|
|
let attr = |name: &str| shader_program.get_attribute_location (&CString::new (name.as_bytes ())?).try_into ().context ("Attribute location negative");
|
|
let uni = |name: &str| shader_program.get_uniform_location (&CString::new (name.as_bytes ())?).try_into ().context ("Uniform location bad");
|
|
|
|
Ok (Self {
|
|
attr_pos: attr ("attr_pos")?,
|
|
attr_normal: attr ("attr_normal")?,
|
|
attr_color: attr ("attr_color")?,
|
|
uni_mvp: uni ("uni_mvp")?,
|
|
})
|
|
}
|
|
}
|
|
|
|
struct TriangleStream {
|
|
pub verts: gpu_buffers::VertexBuffer,
|
|
pub indices: gpu_buffers::IndexBuffer,
|
|
}
|
|
|
|
fn color_from_255 <V> (rgb: V) -> Vec3
|
|
where V: Into <Vec3>
|
|
{
|
|
let rgb: Vec3 = rgb.into ();
|
|
|
|
Vec3::from ((
|
|
rgb.x / 255.0,
|
|
rgb.y / 255.0,
|
|
rgb.z / 255.0
|
|
))
|
|
}
|