375 lines
14 KiB
Rust
375 lines
14 KiB
Rust
use std::collections::HashMap;
|
|
use std::error::Error;
|
|
use std::sync::Arc;
|
|
|
|
use super::settings_scene::SettingsScene;
|
|
use crate::core::app::DEPTH_IMAGE_ID;
|
|
use crate::core::app::context::WindowContext;
|
|
use crate::core::app::user_event::UserEvent;
|
|
use crate::core::render::primitives::camera::Camera3D;
|
|
use crate::core::render::primitives::transform::Transform;
|
|
use crate::core::render::primitives::{AsDescriptorSet, AsRecordable};
|
|
use crate::core::render::render_pass_manager::{RenderPassConfig, RenderPassManager};
|
|
use crate::core::render::resources::meshes::{ObjMesh, SquareMesh};
|
|
use crate::core::render::resources::pipeline::PipelineLoader;
|
|
use crate::core::render::resources::texture::{TextureLoadInfo, TextureLoader, TextureSourceKind};
|
|
use crate::core::scene::Scene;
|
|
use crate::game::assets::pipelines::simple::SimplePipeline;
|
|
use egui_winit_vulkano::egui;
|
|
use glam::EulerRot;
|
|
use glam::Quat;
|
|
use glam::Vec3;
|
|
use vulkano::format::Format;
|
|
use vulkano::image::sampler::{Filter, SamplerAddressMode, SamplerCreateInfo};
|
|
use vulkano::{
|
|
command_buffer::{AutoCommandBufferBuilder, CommandBufferUsage},
|
|
sync::GpuFuture,
|
|
};
|
|
use winit::window::CursorGrabMode;
|
|
|
|
pub struct MainSceneState {
|
|
texture_loader: TextureLoader,
|
|
pipeline_loader: PipelineLoader,
|
|
square: SquareMesh,
|
|
obj: ObjMesh,
|
|
square_instances: Vec<Transform>,
|
|
obj_instances: Vec<Transform>,
|
|
camera: Camera3D,
|
|
speed: f32,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct MainScene {
|
|
state: Option<MainSceneState>,
|
|
}
|
|
|
|
impl Scene for MainScene {
|
|
fn loaded(&self) -> bool {
|
|
self.state.is_some()
|
|
}
|
|
|
|
fn load(&mut self, app_context: &mut WindowContext) -> Result<(), Box<dyn std::error::Error>> {
|
|
let depth_image_view = app_context.with_renderer_mut(|renderer| {
|
|
renderer.get_additional_image_view(DEPTH_IMAGE_ID).clone()
|
|
});
|
|
|
|
let swapchain_image_view =
|
|
app_context.with_renderer(|renderer| renderer.swapchain_image_view().clone());
|
|
|
|
let mut pipeline_loader = PipelineLoader::new(
|
|
app_context.device.clone(),
|
|
swapchain_image_view.format(),
|
|
depth_image_view.format(),
|
|
);
|
|
pipeline_loader.register::<SimplePipeline>()?;
|
|
pipeline_loader.load_pipelines()?;
|
|
|
|
let mut texture_loader = TextureLoader::new(app_context);
|
|
texture_loader.add_texture(
|
|
"wooden-crate".to_string(),
|
|
TextureLoadInfo {
|
|
source: TextureSourceKind::File("res/textures/wooden-crate.jpg".to_string()),
|
|
sampler_create_info: SamplerCreateInfo {
|
|
mag_filter: Filter::Linear,
|
|
min_filter: Filter::Linear,
|
|
address_mode: [SamplerAddressMode::Repeat; 3],
|
|
..Default::default()
|
|
},
|
|
image_format: Format::R8G8B8A8_SRGB,
|
|
},
|
|
);
|
|
texture_loader.add_texture(
|
|
"cube-diffuse".to_string(),
|
|
TextureLoadInfo {
|
|
source: TextureSourceKind::File("res/objects/cube-diffuse.jpg".to_string()),
|
|
sampler_create_info: SamplerCreateInfo {
|
|
mag_filter: Filter::Linear,
|
|
min_filter: Filter::Linear,
|
|
address_mode: [SamplerAddressMode::Repeat; 3],
|
|
..Default::default()
|
|
},
|
|
image_format: Format::R8G8B8A8_SRGB,
|
|
},
|
|
);
|
|
texture_loader.load_pending_textures()?;
|
|
|
|
let square = SquareMesh::new(&app_context.memory_allocator)?;
|
|
|
|
let obj = {
|
|
let obj = ObjMesh::new(&app_context.memory_allocator, "res/objects/cube.obj")?;
|
|
obj.into_iter().next().unwrap()
|
|
};
|
|
|
|
let num_instances = 100;
|
|
let instance_size = 10.0;
|
|
let instance_spacing = 10.0;
|
|
let num_instances_per_row = (num_instances as f32 / instance_spacing).ceil() as u32;
|
|
let square_instances: Vec<Transform> = (0..num_instances)
|
|
.map(|i| {
|
|
Transform::new(
|
|
Vec3::new(
|
|
(i % num_instances_per_row) as f32 * (instance_spacing + instance_size),
|
|
0.0,
|
|
(i / num_instances_per_row) as f32 * (instance_spacing + instance_size),
|
|
),
|
|
Quat::from_euler(EulerRot::XYZ, 0.0, rand::random_range(0.0..=360.0), 0.0),
|
|
Vec3::new(instance_size, instance_size, instance_size),
|
|
)
|
|
})
|
|
.collect();
|
|
|
|
let obj_instances: Vec<Transform> = (0..num_instances)
|
|
.map(|i| {
|
|
Transform::new(
|
|
Vec3::new(
|
|
(i % num_instances_per_row) as f32 * (instance_spacing + instance_size),
|
|
0.0,
|
|
(i / num_instances_per_row) as f32
|
|
* (instance_spacing + instance_size)
|
|
* -1.0
|
|
- instance_spacing * 2.0,
|
|
),
|
|
Quat::from_euler(EulerRot::XYZ, 0.0, rand::random_range(0.0..=360.0), 0.0),
|
|
Vec3::new(
|
|
instance_size * 0.5,
|
|
instance_size * 0.5,
|
|
instance_size * 0.5,
|
|
),
|
|
)
|
|
})
|
|
.collect();
|
|
|
|
let camera = app_context.with_renderer(|renderer| {
|
|
Camera3D::new(
|
|
renderer.aspect_ratio(),
|
|
std::f32::consts::FRAC_PI_2,
|
|
0.01,
|
|
1000.0,
|
|
)
|
|
});
|
|
|
|
self.state = Some(MainSceneState {
|
|
square,
|
|
obj,
|
|
pipeline_loader,
|
|
square_instances,
|
|
obj_instances,
|
|
camera,
|
|
speed: 50.0,
|
|
texture_loader,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn update(&mut self, app_context: &mut WindowContext) -> Result<(), Box<dyn Error>> {
|
|
let state = self.state.as_mut().unwrap();
|
|
app_context.with_input_manager(|input_manager| {
|
|
app_context.with_timer(|timer| {
|
|
state.camera.update(
|
|
input_manager,
|
|
timer,
|
|
state.speed,
|
|
10.0,
|
|
app_context.get_aspect_ratio(),
|
|
);
|
|
});
|
|
});
|
|
|
|
let delta_time = app_context.get_delta_time();
|
|
for (i, instance) in state.square_instances.iter_mut().enumerate() {
|
|
let rotation_speed = (i % 10) as f32;
|
|
let rotation_delta = Quat::from_rotation_y(rotation_speed * delta_time);
|
|
|
|
instance.rotate(rotation_delta);
|
|
}
|
|
|
|
for (i, instance) in state.obj_instances.iter_mut().enumerate() {
|
|
let rotation_speed = (i % 10) as f32;
|
|
let rotation_delta = Quat::from_rotation_y(rotation_speed * delta_time);
|
|
|
|
instance.rotate(rotation_delta);
|
|
}
|
|
|
|
if app_context
|
|
.with_input_manager(|input_manager| input_manager.get_virtual_input_state("mouse_left"))
|
|
> 0.0
|
|
{
|
|
let _ = app_context
|
|
.event_loop_proxy
|
|
.send_event(UserEvent::CursorVisible(app_context.window_id, false));
|
|
let _ = app_context
|
|
.event_loop_proxy
|
|
.send_event(UserEvent::CursorGrabMode(
|
|
app_context.window_id,
|
|
CursorGrabMode::Locked,
|
|
));
|
|
}
|
|
|
|
if app_context.with_input_manager(|input_manager| {
|
|
input_manager.get_virtual_input_state("mouse_right")
|
|
}) > 0.0
|
|
{
|
|
let _ = app_context
|
|
.event_loop_proxy
|
|
.send_event(UserEvent::CursorVisible(app_context.window_id, true));
|
|
let _ = app_context
|
|
.event_loop_proxy
|
|
.send_event(UserEvent::CursorGrabMode(
|
|
app_context.window_id,
|
|
CursorGrabMode::None,
|
|
));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn render(
|
|
&mut self,
|
|
before_future: Box<dyn GpuFuture>,
|
|
app_context: &mut WindowContext,
|
|
) -> Result<Box<dyn GpuFuture>, Box<dyn Error>> {
|
|
let state = self.state.as_mut().ok_or("State not loaded")?;
|
|
|
|
let mut builder = AutoCommandBufferBuilder::primary(
|
|
app_context.command_buffer_allocator.clone(),
|
|
app_context.graphics_queue.queue_family_index(),
|
|
CommandBufferUsage::OneTimeSubmit,
|
|
)?;
|
|
|
|
{
|
|
let swapchain_image_view =
|
|
app_context.with_renderer(|renderer| renderer.swapchain_image_view().clone());
|
|
let depth_image_view = app_context.with_renderer_mut(|renderer| {
|
|
renderer.get_additional_image_view(DEPTH_IMAGE_ID).clone()
|
|
});
|
|
let config = RenderPassConfig::default();
|
|
RenderPassManager::begin_standard_rendering(
|
|
&mut builder,
|
|
&config,
|
|
swapchain_image_view,
|
|
Some(depth_image_view),
|
|
app_context.get_window_size(),
|
|
)?;
|
|
}
|
|
|
|
// Create camera uniform using the actual camera
|
|
let camera_uniform = Arc::new(state.camera.create_buffer(&app_context.memory_allocator)?);
|
|
let square_transform_uniform =
|
|
Transform::create_buffer(&app_context.memory_allocator, &state.square_instances)?;
|
|
let obj_transform_uniform =
|
|
Transform::create_buffer(&app_context.memory_allocator, &state.obj_instances)?;
|
|
|
|
state
|
|
.pipeline_loader
|
|
.with_pipeline::<SimplePipeline, _>(|pipeline| {
|
|
SimplePipeline::record_commands(
|
|
&mut builder,
|
|
&app_context.descriptor_set_allocator,
|
|
pipeline,
|
|
&state.square,
|
|
&square_transform_uniform,
|
|
vec![
|
|
camera_uniform.clone() as Arc<dyn AsDescriptorSet>,
|
|
state
|
|
.texture_loader
|
|
.get_texture("wooden-crate")
|
|
.unwrap()
|
|
.clone(),
|
|
],
|
|
)?;
|
|
|
|
SimplePipeline::record_commands(
|
|
&mut builder,
|
|
&app_context.descriptor_set_allocator,
|
|
pipeline,
|
|
&state.obj,
|
|
&obj_transform_uniform,
|
|
vec![
|
|
camera_uniform.clone() as Arc<dyn AsDescriptorSet>,
|
|
state
|
|
.texture_loader
|
|
.get_texture("cube-diffuse")
|
|
.unwrap()
|
|
.clone(),
|
|
],
|
|
)?;
|
|
|
|
Ok(())
|
|
})?;
|
|
|
|
RenderPassManager::end_rendering(&mut builder)?;
|
|
|
|
let command_buffer = builder.build()?;
|
|
|
|
let render_future =
|
|
before_future.then_execute(app_context.graphics_queue.clone(), command_buffer)?;
|
|
|
|
let swapchain_image_view =
|
|
app_context.with_renderer(|renderer| renderer.swapchain_image_view().clone());
|
|
let input_manager_status =
|
|
app_context.with_input_manager(|input_manager| format!("{:#?}", input_manager));
|
|
let event_loop_proxy = app_context.event_loop_proxy.clone();
|
|
let delta_time = app_context.get_delta_time();
|
|
let window_id = app_context.window_id;
|
|
let window_size = app_context.get_window_size();
|
|
|
|
let render_future = app_context.with_gui_mut(|gui| {
|
|
gui.immediate_ui(|gui| {
|
|
let ctx = gui.context();
|
|
egui::TopBottomPanel::top("top_panel").show(&ctx, |ui| {
|
|
ui.horizontal(|ui| {
|
|
ui.heading("Vulkan Test - Moteur 3D");
|
|
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
|
if ui.button("Paramètres").clicked() {
|
|
let _ = event_loop_proxy.send_event(UserEvent::ChangeScene(
|
|
window_id,
|
|
Box::new(SettingsScene::default()),
|
|
));
|
|
}
|
|
if ui.button("Quitter").clicked() {
|
|
let _ = event_loop_proxy.send_event(UserEvent::Exit(window_id));
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
egui::SidePanel::left("side_panel").show(&ctx, |ui| {
|
|
ui.heading("Informations");
|
|
|
|
ui.separator();
|
|
|
|
ui.label(format!("Résolution: {:?}", window_size));
|
|
ui.label(format!("Delta Time: {:.2}ms", delta_time * 1000.0));
|
|
|
|
ui.separator();
|
|
|
|
ui.label("Position caméra:");
|
|
let position = state.camera.get_position();
|
|
ui.label(format!(" X: {:.2}", position[0]));
|
|
ui.label(format!(" Y: {:.2}", position[1]));
|
|
ui.label(format!(" Z: {:.2}", position[2]));
|
|
|
|
ui.separator();
|
|
|
|
ui.label("Rotation caméra:");
|
|
let rotation = state.camera.get_rotation();
|
|
ui.label(format!(" Yaw: {:.2}°", rotation.y.to_degrees()));
|
|
ui.label(format!(" Pitch: {:.2}°", rotation.x.to_degrees()));
|
|
|
|
ui.separator();
|
|
|
|
ui.label(input_manager_status);
|
|
});
|
|
});
|
|
|
|
gui.draw_on_image(render_future, swapchain_image_view.clone())
|
|
});
|
|
|
|
Ok(render_future)
|
|
}
|
|
|
|
fn unload(&mut self) {
|
|
self.state = None;
|
|
}
|
|
}
|