140 lines
4.8 KiB
Rust
140 lines
4.8 KiB
Rust
mod gfx;
|
|
|
|
use winit::{
|
|
dpi::PhysicalSize,
|
|
event::*,
|
|
event_loop::{ControlFlow, EventLoop},
|
|
window::WindowBuilder,
|
|
};
|
|
|
|
pub async fn run() {
|
|
let event_loop = EventLoop::new();
|
|
let window = WindowBuilder::new()
|
|
.with_title("Haranae")
|
|
.with_inner_size(PhysicalSize::new(1280, 720))
|
|
.build(&event_loop)
|
|
.unwrap();
|
|
|
|
let mut render_ctx = gfx::Context::new(window, wgpu::Limits::default()).await;
|
|
|
|
let shader = render_ctx
|
|
.device
|
|
.create_shader_module(wgpu::include_wgsl!("../res/shaders/main.wgsl"));
|
|
let render_pipeline_layout =
|
|
render_ctx
|
|
.device
|
|
.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: Some("RP Layout"),
|
|
bind_group_layouts: &[],
|
|
push_constant_ranges: &[],
|
|
});
|
|
let render_pipeline =
|
|
render_ctx
|
|
.device
|
|
.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
|
label: Some("Render Pipeline"),
|
|
layout: Some(&render_pipeline_layout),
|
|
vertex: wgpu::VertexState {
|
|
module: &shader,
|
|
entry_point: "vs_main",
|
|
buffers: &[],
|
|
},
|
|
fragment: Some(wgpu::FragmentState {
|
|
module: &shader,
|
|
entry_point: "fs_main",
|
|
targets: &[Some(wgpu::ColorTargetState {
|
|
format: render_ctx.surface_config.format,
|
|
blend: Some(wgpu::BlendState::REPLACE),
|
|
write_mask: wgpu::ColorWrites::ALL,
|
|
})],
|
|
}),
|
|
primitive: wgpu::PrimitiveState {
|
|
topology: wgpu::PrimitiveTopology::TriangleList,
|
|
strip_index_format: None,
|
|
front_face: wgpu::FrontFace::Ccw,
|
|
cull_mode: Some(wgpu::Face::Back),
|
|
unclipped_depth: false,
|
|
polygon_mode: wgpu::PolygonMode::Fill,
|
|
conservative: false,
|
|
},
|
|
depth_stencil: None,
|
|
multisample: wgpu::MultisampleState {
|
|
count: 1,
|
|
mask: !0,
|
|
alpha_to_coverage_enabled: false,
|
|
},
|
|
multiview: None,
|
|
});
|
|
|
|
event_loop.run(move |event, _, control_flow| match event {
|
|
Event::WindowEvent {
|
|
ref event,
|
|
window_id,
|
|
} if window_id == render_ctx.window.id() => match event {
|
|
WindowEvent::CloseRequested
|
|
| WindowEvent::KeyboardInput {
|
|
input:
|
|
KeyboardInput {
|
|
state: ElementState::Pressed,
|
|
virtual_keycode: Some(VirtualKeyCode::Escape),
|
|
..
|
|
},
|
|
..
|
|
} => *control_flow = ControlFlow::Exit,
|
|
WindowEvent::Resized(physical_size) => {
|
|
render_ctx.resize(*physical_size);
|
|
}
|
|
WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
|
|
render_ctx.resize(**new_inner_size);
|
|
}
|
|
_ => {}
|
|
},
|
|
Event::RedrawRequested(window_id) if window_id == render_ctx.window.id() => {
|
|
let output = match render_ctx.surface.get_current_texture() {
|
|
Ok(it) => it,
|
|
Err(err) => return log::error!("{err}"),
|
|
};
|
|
|
|
let view = output
|
|
.texture
|
|
.create_view(&wgpu::TextureViewDescriptor::default());
|
|
|
|
let mut encoder =
|
|
render_ctx
|
|
.device
|
|
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
|
|
label: Some("Render encoder"),
|
|
});
|
|
|
|
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
|
label: Some("Render Pass"),
|
|
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
|
view: &view,
|
|
resolve_target: None,
|
|
ops: wgpu::Operations {
|
|
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
|
|
store: true,
|
|
},
|
|
})],
|
|
depth_stencil_attachment: None,
|
|
});
|
|
render_pass.set_pipeline(&render_pipeline);
|
|
render_pass.draw(0..3, 0..1);
|
|
|
|
drop(render_pass);
|
|
|
|
render_ctx.queue.submit(std::iter::once(encoder.finish()));
|
|
output.present();
|
|
}
|
|
Event::MainEventsCleared => {
|
|
render_ctx.window.request_redraw();
|
|
}
|
|
_ => {}
|
|
});
|
|
}
|
|
|
|
fn main() {
|
|
env_logger::init();
|
|
pollster::block_on(run());
|
|
}
|