use crate::ecs::{Camera, Rotation, Scale, Shear, SpriteTexture, Translation};
use crate::rendering::assets::Assets;
use crate::rendering::mipmap::MipGenerator;
use crate::rendering::renderer::RenderInitRes::{Initialized, NotReadyYet};
use crate::rendering::texture;
use crate::rendering::ui::UiRenderable;
use bevy_ecs::schedule::Schedule;
use bevy_ecs::world::World;
use egui::ViewportId;
use std::collections::HashMap;
use std::fmt::{Debug, Formatter};
use std::sync::Arc;
use tracing::info;
use web_time::Instant;
use wgpu::SurfaceConfiguration;
use wgpu::{
include_wgsl, Adapter, Backends, BindGroupDescriptor, BindGroupEntry, BindingResource, Buffer,
BufferDescriptor, BufferUsages, Color, ColorTargetState, CommandEncoderDescriptor, Device,
DeviceDescriptor, Features, FragmentState, Instance, InstanceDescriptor, Limits, LoadOp,
Operations, Queue, RenderPassColorAttachment, RenderPassDescriptor, RenderPipeline,
RenderPipelineDescriptor, RequestAdapterOptions, ShaderModule, StoreOp, Surface,
TextureViewDescriptor, VertexState,
};
use winit::dpi::{LogicalSize, PhysicalSize};
use winit::window::Window;
#[allow(unused_attributes, dead_code)]
pub struct Renderer<T: UiRenderable> {
pub last_frame_time: Instant,
pub surface: Surface<'static>,
pub surface_configuration: SurfaceConfiguration,
pub device: Device,
pub queue: Queue,
pub adapter: Adapter,
pub sprite_shader_module: ShaderModule,
pub sprite_pipeline: RenderPipeline,
pub world: World,
pub update_schedule: Schedule,
pub gui_ctx: egui::Context,
pub gui_winit: egui_winit::State,
pub gui_renderer: egui_wgpu::Renderer,
pub gui_renderable: T,
pub textures: HashMap<String, texture::Texture>,
pub mip_generator: MipGenerator,
pub frame_uniform: Buffer,
pub local_uniform: Buffer,
pub scale_factor: f64,
pub window: Arc<Window>,
pub size: PhysicalSize<u32>,
pub logical_size: LogicalSize<u32>,
}
#[allow(clippy::large_enum_variant)]
pub enum RenderInitRes<T: UiRenderable> {
Initialized(Renderer<T>),
NotReadyYet(World, Schedule, T),
}
impl<T: UiRenderable> Debug for RenderInitRes<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Initialized(..) => write!(f, "[initialized renderer]"),
NotReadyYet(..) => write!(f, "[pending initialization]"),
}
}
}
impl<T: UiRenderable> Renderer<T> {
pub async fn try_init(
window: Arc<Window>,
world: World,
update_schedule: Schedule,
gui_renderable: T,
) -> RenderInitRes<T> {
let size = window.inner_size();
if size.width == 0 || size.height == 0 {
return NotReadyYet(world, update_schedule, gui_renderable);
}
// First, create an instance. This is our handle to wgpu, and is the equivalent of navigator.gpu in WebGPU
let instance = Instance::new(InstanceDescriptor {
backends: Backends::all(), // Select the appropriate backend for the HAL to use. Defined in the platform module, as it's platform-specific
..Default::default() // Other fields aren't relevant here
});
// Next, get our render surface
let surface = instance.create_surface(window.clone()).unwrap();
// Next, request out adapter
let adapter = instance
.request_adapter(&RequestAdapterOptions {
power_preference: Default::default(), // Don't care
force_fallback_adapter: false, // We want a real GPU
compatible_surface: Some(&surface), // Find an adapter that is able to render to our window
})
.await
.unwrap();
let mut limits = Limits::downlevel_webgl2_defaults();
limits.max_texture_dimension_1d = 8192;
limits.max_texture_dimension_2d = 8192;
limits.max_texture_dimension_3d = 2048;
let (device, queue) = adapter
.request_device(
&DeviceDescriptor {
label: Some("Basic render device"),
required_features: Features::default(),
required_limits: limits,
memory_hints: Default::default(),
},
None,
)
.await
.unwrap();
let format = surface
.get_default_config(&adapter, size.width, size.height)
.unwrap();
surface.configure(&device, &format);
let sprite_shader_module =
device.create_shader_module(include_wgsl!("../shaders/sprite.wgsl"));
let sprite_pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
label: Some("Sprite pipeline"),
layout: None,
vertex: VertexState {
module: &sprite_shader_module,
entry_point: Some("vs"),
compilation_options: Default::default(),
buffers: &[],
},
primitive: Default::default(),
depth_stencil: None,
multisample: Default::default(),
fragment: Some(FragmentState {
module: &sprite_shader_module,
entry_point: Some("fs"),
compilation_options: Default::default(),
targets: &[Some(ColorTargetState {
format: format.format,
blend: None,
write_mask: Default::default(),
})],
}),
multiview: None,
cache: None,
});
let gui_context = egui::Context::default();
let gui_winit = egui_winit::State::new(
gui_context.clone(),
ViewportId::ROOT,
&window,
Some(window.scale_factor() as f32),
None,
Some(device.limits().max_texture_dimension_2d as usize),
);
let gui_renderer = egui_wgpu::Renderer::new(&device, format.format, None, 1, false);
let frame_uniform = device.create_buffer(&BufferDescriptor {
label: Some("frame uniforms"),
size: 48 + 16, // mat3x3f, vec2f
usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let local_uniform = device.create_buffer(&BufferDescriptor {
label: Some("local uniforms"),
size: 48, // mat3x3f
usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
mapped_at_creation: false,
});
Initialized(Self {
mip_generator: MipGenerator::new(&device),
textures: HashMap::new(),
last_frame_time: Instant::now(),
surface,
device,
queue,
adapter,
sprite_shader_module,
sprite_pipeline,
world,
update_schedule,
gui_ctx: gui_context,
gui_winit,
gui_renderer,
gui_renderable,
logical_size: LogicalSize::from_physical(size, window.scale_factor()),
scale_factor: window.scale_factor(),
window,
frame_uniform,
local_uniform,
size,
surface_configuration: format,
})
}
pub fn render(&mut self) {
// update the world
self.update_schedule.run(&mut self.world);
// update the UI
let egui_output = self
.gui_ctx
.run(self.gui_winit.take_egui_input(&self.window), |ctx| {
self.gui_renderable.render(ctx, &mut self.world)
});
self.gui_winit
.handle_platform_output(&self.window, egui_output.platform_output);
let output = self.surface.get_current_texture().unwrap();
let view = output
.texture
.create_view(&TextureViewDescriptor::default());
let render_pass_descriptor = RenderPassDescriptor {
label: Some("basic render pass"),
color_attachments: &[Some(RenderPassColorAttachment {
view: &view,
resolve_target: None,
ops: Operations {
load: LoadOp::Clear(Color {
r: 0.3,
g: 0.3,
b: 0.3,
a: 1.0,
}),
store: StoreOp::Store,
},
})],
..Default::default()
};
let mut encoder = self
.device
.create_command_encoder(&CommandEncoderDescriptor {
label: Some("command encoder"),
});
let mut sprites_to_render: Vec<(Translation, Shear, Scale, SpriteTexture, Rotation)> = vec![];
let mut things_to_render = self.world.query::<(&Translation, &Shear, &Scale, &SpriteTexture, &Rotation)>();
for thing in things_to_render.iter_mut(&mut self.world) {
sprites_to_render.push((*thing.0, *thing.1, *thing.2, thing.3.clone(), *thing.4));
}
let cam = self.world.resource::<Camera>();
let mut frame_uniform = vec![];
let frame_uniform_values = [
cam.zoom, cam.shear_y,0.0, 0.0,
cam.shear_x,cam.zoom, 0.0, 0.0,
cam.x, cam.y, 1.0, 0.0,
self.logical_size.width as f32, self.logical_size.height as f32, 0.0, 0.0];
for i in frame_uniform_values {
let mut bytes = i.to_ne_bytes().to_vec();
frame_uniform.append(&mut bytes);
}
self.queue.write_buffer(&self.frame_uniform, 0, &frame_uniform);
for (pos, shear, scale, tex, rot) in sprites_to_render {
let tex = self.textures.entry(tex.texture.clone()).or_insert({
info!("loading texture {}", &tex.texture);
let assets = self.world.get_resource::<Assets>().unwrap();
let b = match tex.texture.as_str() {
"f" => match assets.get("f.png") {
Some(b) => b,
None => continue,
}
"happy-tree" => match assets.get("happy-tree.png") {
Some(b) => b,
None => continue,
}
"uv" => match assets.get("uv.png") {
Some(b) => b,
None => continue,
}
u => panic!("unknown texture {u}, has it been added in rendering::renderer::<impl Renderer>::render()?")
};
tracing::warn!("{:?}", b);
/*let b: &[u8] = match tex.texture.as_str() {
"f" => include_bytes!("../textures/f.png"),
"happy-tree" => include_bytes!("../textures/happy-tree.png"),
"uv" => include_bytes!("../textures/uv.png"),
u => panic!("unknown texture {u}, has it been added in rendering::renderer::<impl Renderer>::render()?")
};*/
texture::Texture::new(
&b,
&tex.texture,
&self.device,
&self.queue,
&mut self.mip_generator,
)
});
let xy_matrix = pos.as_matrix();
let shear_matrix = shear.as_matrix();
let rot_matrix = rot.as_matrix();
let scale_matrix = scale.as_matrix();
let transform_matrix = scale_matrix * shear_matrix * rot_matrix * xy_matrix;
let mut local_buffer = vec![];
let local_buffer_data = [
transform_matrix.m11, transform_matrix.m12, transform_matrix.m13, 0.0,
transform_matrix.m21, transform_matrix.m22, transform_matrix.m23, 0.0,
transform_matrix.m31, transform_matrix.m32, transform_matrix.m33, 0.0,
];
for i in local_buffer_data {
let mut bytes = i.to_ne_bytes().to_vec();
local_buffer.append(&mut bytes);
}
self.queue
.write_buffer(&self.local_uniform, 0, &local_buffer);
let bind_group = self.device.create_bind_group(&BindGroupDescriptor {
label: Some("test_bind_group"),
layout: &self.sprite_pipeline.get_bind_group_layout(0),
entries: &[
BindGroupEntry {
binding: 0,
resource: BindingResource::Sampler(&tex.sampler),
},
BindGroupEntry {
binding: 1,
resource: BindingResource::TextureView(
&tex.texture.create_view(&TextureViewDescriptor::default()),
),
},
BindGroupEntry {
binding: 2,
resource: BindingResource::Buffer(
self.frame_uniform.as_entire_buffer_binding(),
),
},
BindGroupEntry {
binding: 3,
resource: BindingResource::Buffer(
self.local_uniform.as_entire_buffer_binding(),
),
},
],
});
let mut pass = encoder.begin_render_pass(&render_pass_descriptor);
pass.set_pipeline(&self.sprite_pipeline);
pass.set_bind_group(0, Some(&bind_group), &[]);
pass.draw(0..6, 0..1);
}
// main game rendering done
// next up: egui UI rendering
for (id, image_delta) in &egui_output.textures_delta.set {
self.gui_renderer
.update_texture(&self.device, &self.queue, *id, image_delta);
}
{
let paint_jobs = self
.gui_ctx
.tessellate(egui_output.shapes, self.scale_factor as f32);
let screen_descriptor = egui_wgpu::ScreenDescriptor {
size_in_pixels: [self.size.width, self.size.height],
pixels_per_point: self.scale_factor as f32,
};
self.gui_renderer.update_buffers(
&self.device,
&self.queue,
&mut encoder,
&paint_jobs,
&screen_descriptor,
);
let render_pass = encoder.begin_render_pass(&RenderPassDescriptor {
label: Some("ui render pass"),
color_attachments: &[Some(RenderPassColorAttachment {
view: &view,
resolve_target: None,
ops: Operations {
load: LoadOp::Load,
store: StoreOp::Store,
},
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
});
let mut forgotten_render_pass = render_pass.forget_lifetime();
self.gui_renderer
.render(&mut forgotten_render_pass, &paint_jobs, &screen_descriptor);
for id in egui_output.textures_delta.free {
self.gui_renderer.free_texture(&id);
}
}
let buffer = encoder.finish();
self.queue.submit(std::iter::once(buffer));
output.present();
}
}