asuro/rust-engine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Modules and stuff

Browse Source
This commit is contained in:
Asuro
2020-12-02 10:21:33 +01:00
parent e054a76a3f
commit be1d5e6221
10 changed files with 231 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/config.rs
View File

@@ -1,6 +1,8 @@
use serde_derive::{Serialize, Deserialize};
use toml;
use std::fs;
use serde_derive::{Deserialize, Serialize};
use toml;
#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
pub struct LogConfigInput {
pub mouse_motion: bool,

4
src/level.rs → src/game/level.rs
View File

@@ -1,8 +1,10 @@
use std::{error::Error, io::{BufReader, BufWriter}};
use std::fs::File;
use serde_derive::{Deserialize, Serialize};
use crate::{TestGame, gameobject::GameObjectHandle, vulkan::{MeshHandle, VulkanRenderer}};
use crate::{vulkan::{MeshHandle, VulkanRenderer, gameobject::GameObjectHandle}};
use crate::game::TestGame;
#[derive(Debug, Serialize, Deserialize)]
struct MeshJson {

155
src/game/mod.rs Normal file
View File

@@ -0,0 +1,155 @@
use winit::event::Event;
use level::{load_level, save_level};
use player::Player;
use crate::config::{LogConfig};
use crate::input::InputState;
use crate::vulkan::{Game, MeshHandle, VulkanRenderer};
use crate::vulkan::gameobject::{GameObject, GameObjectHandle, Updatable};
use crate::vulkan::mesh;
use crate::vulkan::pipelines::vs::ty::ObjectUniformData;
pub mod player;
mod level;
pub struct TestGame {
pub input: InputState,
pub player: Player,
pub game_objects: Vec<GameObjectHandle>,
pub log_config: LogConfig,
pub texture_index_counter: usize,
pub last_time: f32,
pub components: Vec<Box<dyn Updatable>>,
}
impl Game for TestGame {
fn on_window_event(self: &mut Self, event: &Event<()>) {
self.input.on_window_event(event);
}
fn update(self: &mut Self, renderer: &mut VulkanRenderer) -> ObjectUniformData {
// Input and timing
self.input.frame_start();
let time = (renderer.game_data.start_time.elapsed().unwrap().as_micros() as f64 / 1000000.0) as f32;
let frame_time = time - self.last_time;
// Component update
let input = &self.input;
let components = &mut self.components;
components.iter_mut().for_each(|component| {
component.update(frame_time, &input, renderer);
});
// User interaction
if self.input.button_just_released("quit") {
renderer.game_data.shutdown = true;
}
if self.input.button_just_pressed("reload_shaders") {
renderer.game_data.recreate_pipeline = true;
}
if self.input.button_just_pressed("quicksave") {
save_level("levels/test.lvl", self, renderer).unwrap();
}
if self.input.button_just_pressed("quickload") {
self.clear_level(renderer);
load_level("levels/test.lvl", self, renderer).unwrap();
}
if self.input.button_down("print_framerate") {
println!("{:.0} ms / {:.0} FPS", frame_time * 1000.0, 1.0 / frame_time);
}
// Custom game object stuff
let light_pos = self.player.camera.position * -1.0;
self.player.update(frame_time, &self.input, renderer);
// End frame
self.last_time = time;
self.input.frame_end();
ObjectUniformData {
view: self.player.camera.view.into(),
projection: self.player.camera.proj.into(),
time,
light_position: light_pos.into(),
camera_position: self.player.camera.position.into(),
_dummy0: [0; 12],
_dummy1: [0; 4],
}
}
}
impl TestGame {
pub fn new(toml_path: &str, log_config: LogConfig) -> TestGame {
TestGame {
input: InputState::new(toml_path, log_config),
player: Player::new(),
game_objects: vec![],
log_config,
texture_index_counter: 0,
last_time: 0.0,
components: vec![],
}
}
pub fn game_start(self: &mut Self, renderer: &mut VulkanRenderer) {
// let plane_mesh = self.load_gltf(renderer, "models/plane.gltf");
// self.add_game_object(renderer, plane_mesh[0].clone());
load_level("levels/test.lvl", self, renderer).unwrap();
println!("Game loaded!");
}
pub fn offset_texture_id(&mut self, local_tex_id: Option<usize>) -> usize {
match local_tex_id {
Some(local_id) => local_id + self.texture_index_counter,
None => 0,
}
}
pub fn load_gltf(&mut self, renderer: &mut VulkanRenderer, gltf_path: &str) -> Vec<MeshHandle> {
let mut mesh_handles = Vec::new();
// Load file
let (meshes, textures) = mesh::load_mesh(gltf_path, self.log_config.mesh_load_info).unwrap();
for cpu_mesh in meshes.into_iter() {
// Convert file texture id to game texture id
let diffuse_id = self.offset_texture_id(cpu_mesh.local_texture_index);
let normal_id = self.offset_texture_id(cpu_mesh.local_normal_map_index);
// Upload mesh
let mesh_id = renderer.upload_mesh(cpu_mesh, gltf_path.to_string());
let mesh_handle = MeshHandle {
index: mesh_id,
diffuse_handle: diffuse_id,
normal_handle: normal_id,
original_path: gltf_path.to_string()
};
mesh_handles.push(mesh_handle);
}
textures.iter().for_each(|tex| {
renderer.upload_texture(tex);
self.texture_index_counter += 1;
});
mesh_handles
}
pub fn add_game_object(&mut self, renderer: &mut VulkanRenderer, mesh: MeshHandle) -> GameObjectHandle {
let obj = GameObject::new(mesh);
let obj_handle = renderer.add_game_object(obj, 0);
self.game_objects.push(obj_handle);
self.game_objects.last().unwrap().clone()
}
pub fn clear_level(&mut self, renderer: &mut VulkanRenderer) {
self.game_objects.clear();
self.texture_index_counter = 0;
renderer.clear_all();
}
}

14
src/player.rs → src/game/player.rs
View File

@@ -1,11 +1,13 @@
use cgmath::{Deg, InnerSpace, Matrix4, One, Quaternion, Rad, Rotation, Rotation3, SquareMatrix, vec3, Vector3};
use crate::game::player::PlayerMovementMode::{FirstPerson, Flying};
use crate::input::InputState;
use crate::MeshHandle;
use cgmath::{vec3, One, SquareMatrix, Deg, Rad, Quaternion, Vector3, Matrix4, Rotation, Rotation3, InnerSpace};
use crate::{
VulkanRenderer,
input::InputState,
gameobject::Updatable
use crate::vulkan::{
gameobject::Updatable,
VulkanRenderer
};
use crate::player::PlayerMovementMode::{FirstPerson, Flying};
pub struct Camera {
pub fov_y: f32,

11
src/input.rs
View File

@@ -1,17 +1,14 @@
#![allow(deprecated)]
use winit::event::{ScanCode, MouseButton, ElementState, MouseScrollDelta, Event, WindowEvent, DeviceEvent, ModifiersState};
use std::collections::{HashMap, HashSet};
use std::fs;
use std::iter::FromIterator;
use toml;
use serde_derive::{Serialize, Deserialize};
use gilrs;
use gilrs::{Gilrs, EventType};
use gilrs::{EventType, Gilrs};
use serde_derive::{Deserialize, Serialize};
use toml;
use winit::event::{DeviceEvent, ElementState, Event, ModifiersState, MouseButton, MouseScrollDelta, ScanCode, WindowEvent};
use crate::config::LogConfig;

169
src/main.rs
View File

@@ -1,172 +1,19 @@
extern crate serde_json;
use cgmath::{Matrix4, Vector3, Vector4};
use level::{load_level, save_level};
use winit::event::Event;
use vulkan::gameobject::GameObject;
use crate::config::{LogConfig, RenderConfig};
use crate::gameobject::{GameObject, GameObjectHandle, Updatable};
use crate::input::InputState;
use crate::player::Player;
use crate::vulkan::{Game, LinePoint, MeshHandle, VulkanRenderer};
use crate::pipelines::vs::ty::ObjectUniformData;
use crate::game::TestGame;
use crate::vulkan::{LinePoint, MeshHandle, VulkanRenderer};
mod vulkan;
mod input;
mod config;
mod mesh;
mod gameobject;
mod player;
mod pipelines;
mod level;
pub struct TestGame {
input: InputState,
player: Player,
game_objects: Vec<GameObjectHandle>,
log_config: LogConfig,
texture_index_counter: usize,
last_time: f32,
components: Vec<Box<dyn Updatable>>,
}
impl TestGame {
fn new(toml_path: &str, log_config: LogConfig) -> TestGame {
TestGame {
input: InputState::new(toml_path, log_config),
player: Player::new(),
game_objects: vec![],
log_config,
texture_index_counter: 0,
last_time: 0.0,
components: vec![],
}
}
}
impl Game for TestGame {
fn on_window_event(self: &mut Self, event: &Event<()>) {
self.input.on_window_event(event);
}
fn update(self: &mut Self, renderer: &mut VulkanRenderer) -> ObjectUniformData {
// Input and timing
self.input.frame_start();
let time = (renderer.game_data.start_time.elapsed().unwrap().as_micros() as f64 / 1000000.0) as f32;
let frame_time = time - self.last_time;
// Component update
let input = &self.input;
let components = &mut self.components;
components.iter_mut().for_each(|component| {
component.update(frame_time, &input, renderer);
});
// User interaction
if self.input.button_just_released("quit") {
renderer.game_data.shutdown = true;
}
if self.input.button_just_pressed("reload_shaders") {
renderer.game_data.recreate_pipeline = true;
}
if self.input.button_just_pressed("quicksave") {
save_level("levels/test.lvl", self, renderer).unwrap();
}
if self.input.button_just_pressed("quickload") {
self.clear_level(renderer);
load_level("levels/test.lvl", self, renderer).unwrap();
}
if self.input.button_down("print_framerate") {
println!("{:.0} ms / {:.0} FPS", frame_time * 1000.0, 1.0 / frame_time);
}
// Custom game object stuff
let light_pos = self.player.camera.position * -1.0;
self.player.update(frame_time, &self.input, renderer);
// End frame
self.last_time = time;
self.input.frame_end();
ObjectUniformData {
view: self.player.camera.view.into(),
projection: self.player.camera.proj.into(),
time,
light_position: light_pos.into(),
camera_position: self.player.camera.position.into(),
_dummy0: [0; 12],
_dummy1: [0; 4],
}
}
}
fn _matrix_vector_mul(matrix: &Matrix4<f32>, vector: &Vector3<f32>) -> Vector3<f32> {
let v4 = Vector4::new(vector.x, vector.y, vector.z, 1.0);
let out = matrix * v4;
Vector3::new(out.x, out.y, out.z)
}
impl TestGame {
fn game_start(self: &mut Self, renderer: &mut VulkanRenderer) {
// let plane_mesh = self.load_gltf(renderer, "models/plane.gltf");
// self.add_game_object(renderer, plane_mesh[0].clone());
load_level("levels/test.lvl", self, renderer).unwrap();
println!("Game loaded!");
}
fn offset_texture_id(&mut self, local_tex_id: Option<usize>) -> usize {
match local_tex_id {
Some(local_id) => local_id + self.texture_index_counter,
None => 0,
}
}
fn load_gltf(&mut self, renderer: &mut VulkanRenderer, gltf_path: &str) -> Vec<MeshHandle> {
let mut mesh_handles = Vec::new();
// Load file
let (meshes, textures) = mesh::load_mesh(gltf_path, self.log_config.mesh_load_info).unwrap();
for cpu_mesh in meshes.into_iter() {
// Convert file texture id to game texture id
let diffuse_id = self.offset_texture_id(cpu_mesh.local_texture_index);
let normal_id = self.offset_texture_id(cpu_mesh.local_normal_map_index);
// Upload mesh
let mesh_id = renderer.upload_mesh(cpu_mesh, gltf_path.to_string());
let mesh_handle = MeshHandle {
index: mesh_id,
diffuse_handle: diffuse_id,
normal_handle: normal_id,
original_path: gltf_path.to_string()
};
mesh_handles.push(mesh_handle);
}
textures.iter().for_each(|tex| {
renderer.upload_texture(tex);
self.texture_index_counter += 1;
});
mesh_handles
}
fn add_game_object(&mut self, renderer: &mut VulkanRenderer, mesh: MeshHandle) -> GameObjectHandle {
let obj = GameObject::new(mesh);
let obj_handle = renderer.add_game_object(obj, 0);
self.game_objects.push(obj_handle);
self.game_objects.last().unwrap().clone()
}
fn clear_level(&mut self, renderer: &mut VulkanRenderer) {
self.game_objects.clear();
self.texture_index_counter = 0;
renderer.clear_all();
}
}
mod game;
fn main() {
let log_config = LogConfig::from_file("config/log.toml");

8
src/gameobject.rs → src/vulkan/gameobject.rs
View File

@@ -1,8 +1,10 @@
use std::sync::Arc;
use crate::vulkan::{RendererDescriptorSets, TextureHandle};
use cgmath::{Matrix4, Vector3, Quaternion, Euler, Deg};
use crate::vulkan::{MeshHandle, VulkanRenderer};
use cgmath::{Deg, Euler, Matrix4, Quaternion, Vector3};
use crate::input::InputState;
use crate::vulkan::{RendererDescriptorSets, TextureHandle};
use crate::vulkan::{MeshHandle, VulkanRenderer};
#[derive(Clone)]
pub struct GameObject {

2
src/mesh.rs → src/vulkan/mesh.rs
View File

@@ -3,7 +3,7 @@ use std::time::SystemTime;
use gltf::Error;
use gltf::mesh::util::{ReadJoints, ReadNormals, ReadPositions, ReadTangents, ReadTexCoords, ReadWeights};
use crate::mesh::LoadError::{GltfError, MeshDataMissing, NoIndices};
use crate::vulkan::mesh::LoadError::{GltfError, MeshDataMissing, NoIndices};
use crate::vulkan::Vertex;
#[derive(Debug)]

22
src/vulkan.rs → src/vulkan/mod.rs
View File

@@ -1,18 +1,16 @@
use crate::pipelines::{Drawcall, LineShader};
use crate::pipelines::DefaultShader;
use std::sync::Arc;
use std::time::SystemTime;
use cgmath::{Matrix4, SquareMatrix};
use image::{ImageBuffer, Rgb, Rgba};
use image::buffer::ConvertBuffer;
use vulkano::{command_buffer::CommandBuffer, buffer::{BufferUsage, CpuAccessibleBuffer}, image::{ImageLayout, MipmapsCount}};
use vulkano::{buffer::{BufferUsage, CpuAccessibleBuffer}, command_buffer::CommandBuffer, image::{ImageLayout, MipmapsCount}};
use vulkano::command_buffer::{AutoCommandBuffer, AutoCommandBufferBuilder, DynamicState};
use vulkano::descriptor::DescriptorSet;
use vulkano::device::{Device, DeviceExtensions, Queue};
use vulkano::format::{ClearValue, Format};
use vulkano::framebuffer::{Framebuffer, FramebufferAbstract, RenderPassAbstract};
use vulkano::image::{AttachmentImage, Dimensions, ImageUsage, ImmutableImage, SwapchainImage, ImageViewAccess};
use vulkano::image::{AttachmentImage, Dimensions, ImageUsage, ImageViewAccess, ImmutableImage, SwapchainImage};
use vulkano::instance::{ApplicationInfo, Instance, InstanceExtensions, PhysicalDevice, Version};
use vulkano::instance::debug::{DebugCallback, MessageSeverity, MessageType};
use vulkano::pipeline::viewport::Viewport;
@@ -26,13 +24,19 @@ use winit::event::{Event, WindowEvent};
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::{Window, WindowBuilder};
use crate::pipelines::{line_vs::ty::LinePushConstants};
use crate::pipelines::vs::ty::PushConstants;
use mesh::CPUMesh;
use pipelines::{Drawcall, LineShader};
use pipelines::{line_vs::ty::LinePushConstants};
use pipelines::DefaultShader;
use pipelines::vs;
use pipelines::vs::ty::PushConstants;
use crate::pipelines::vs;
use crate::{gameobject::{GameObject, GameObjectHandle}};
use crate::mesh::CPUMesh;
use crate::config::RenderConfig;
use crate::vulkan::{gameobject::{GameObject, GameObjectHandle}};
pub mod pipelines;
pub mod gameobject;
pub mod mesh;
const VALIDATION_LAYERS: &[&str] = &[
"VK_LAYER_KHRONOS_validation"

56
src/pipelines.rs → src/vulkan/pipelines.rs
View File

@@ -1,15 +1,17 @@
use vulkano::command_buffer::DynamicState;
use crate::vulkan::GameData;
use crate::vulkan::{LinePoint, Vertex};
use crate::GameObject;
use vulkano::{command_buffer::AutoCommandBufferBuilder, descriptor::descriptor_set::PersistentDescriptorSet};
use crate::VulkanRenderer;
use vulkano::pipeline::{GraphicsPipeline};
use vulkano::framebuffer::Subpass;
use vulkano::pipeline::GraphicsPipelineAbstract;
use vulkano::framebuffer::RenderPassAbstract;
use std::sync::Arc;
use vulkano::{command_buffer::AutoCommandBufferBuilder, descriptor::descriptor_set::PersistentDescriptorSet};
use vulkano::command_buffer::DynamicState;
use vulkano::device::Device;
use vulkano::framebuffer::RenderPassAbstract;
use vulkano::framebuffer::Subpass;
use vulkano::pipeline::GraphicsPipeline;
use vulkano::pipeline::GraphicsPipelineAbstract;
use crate::GameObject;
use crate::vulkan::{LinePoint, Vertex};
use crate::vulkan::GameData;
use crate::VulkanRenderer;
type RP = Arc<dyn RenderPassAbstract + Send + Sync>;
type GP = Arc<dyn GraphicsPipelineAbstract + Send + Sync>;
@@ -68,8 +70,21 @@ impl DefaultShader {
}
impl Drawcall for DefaultShader {
fn recreate_pipeline(self: &mut Self, device: Arc<Device>, render_pass: RP) {
self.pipeline = Self::create_pipeline(device, render_pass);
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder, fb_index: usize, game_data: &GameData, dynamic_state: &DynamicState) {
for i in 0..game_data.game_objects.len() {
let game_object = &game_data.game_objects[i];
let mesh = &game_data.meshes[game_object.mesh_index];
let mut push_constants = game_data.push_constants.clone();
push_constants.model = game_object.get_model_matrix().into();
builder.draw_indexed(
self.pipeline.clone(),
dynamic_state,
vec![mesh.vertex_buffer.clone()],
mesh.index_buffer.clone(),
game_object.descriptor_sets[fb_index].clone(),
push_constants).unwrap();
}
}
fn create_descriptor_set(self: &Self, game_object: &mut GameObject, renderer: &VulkanRenderer) {
@@ -91,21 +106,8 @@ impl Drawcall for DefaultShader {
}).collect();
}
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder, fb_index: usize, game_data: &GameData, dynamic_state: &DynamicState) {
for i in 0..game_data.game_objects.len() {
let game_object = &game_data.game_objects[i];
let mesh = &game_data.meshes[game_object.mesh_index];
let mut push_constants = game_data.push_constants.clone();
push_constants.model = game_object.get_model_matrix().into();
builder.draw_indexed(
self.pipeline.clone(),
dynamic_state,
vec![mesh.vertex_buffer.clone()],
mesh.index_buffer.clone(),
game_object.descriptor_sets[fb_index].clone(),
push_constants).unwrap();
}
fn recreate_pipeline(self: &mut Self, device: Arc<Device>, render_pass: RP) {
self.pipeline = Self::create_pipeline(device, render_pass);
}
fn get_pipeline(self: &Self) -> &GP {