이전 글에서 이어집니다.
유니폼
Boring, I know
이전 정점 버퍼는 각 정점당 임의의 값을 전달했다. 그런데 내가 전달하고자 하는 값이 보간이 필요 없고, 프래그먼트 셰이더에서만 사용할 값이라면 굳이 정점 버퍼로 전달할 이유가 없다. 지금이야 정점이 4개지만, 어쩌다 보면 정점이 수만 개가 될 수도 있기 때문이다. 같은 값을 수만 개의 정점에 일일이 집어넣을 필요는 없다. 유니폼(uniform)은 정점 셰이더와 프래그먼트 셰이더에서 공통으로 읽는 값이다. 따라서 이를 이용해 값을 셰이더로 전달하면 더 경제적일 것이다.
정점 버퍼를 전달할 땐 버퍼의 입력 위치(set_vertex_buffer의 첫 인자)와 이를 어떻게 읽을지 정하는 정점 버퍼 레이아웃, 그리고 WGSL 정점 셰이더에서의 입력 위치만 신경 쓰면 그만이었다. 반면 유니폼은 BindGroup으로 입력하고 사용한다. WGSL에선 BindGroup을 @group으로, 그 안의 슬롯을 @binding으로 가리킨다. @group은 비유하자면 서랍이며, @binding은 그 서랍의 칸이다. 어떤 슬롯에 무엇을 넣을지 정하는 명세가 BindGroupLayout이다. 유니폼 버퍼와 BindGroupLayout을 이용해 BindGroup을 만들 수 있다. BindGroupLayout은 PipelineLayout을 만들 때도 사용된다. RenderPipeline은 연결되는 BindGroup에 따라 형태가 정해지지 않고, 처음 만들어질 때부터 모양이 고정된다. 따라서 어떤 식으로 BindGroup을 사용할지 PipelineLayout을 통해 파악하고 있어야 한다. 마지막으로 RenderPass의 set_bind_group으로 슬롯에 맞게 BindGroup을 입력하면 된다.
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct GlobalUniform {
resolution: [f32;2],
time: f32,
frame: u32,
}사용할 유니폼 구조체를 정의한다. 버퍼로 전달할 예정이기에 C의 메모리 규칙과 Pod를 부여한다.
let global_uniform = GlobalUniform {
resolution: [size.width as f32, size.height as f32],
time: 0.0,
frame: 0,
};
let global_uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("global_uniform_buffer"),
contents: bytemuck::bytes_of(&global_uniform),
usage: wgpu::BufferUsages::UNIFORM,
});GPU 상태 초기화 메서드 내에 유니폼 버퍼를 만든다. 정점 버퍼와 기본적으로 동일하다. BufferUsages는 UNIFORM으로 하고, 배열이 아니기에 bytemuck::bytes_of를 사용해 바이트 단위로 전달한다.
let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("bind_group_layout"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}],
});BindGroupLayout을 만든다. BindGroupLayoutDescriptor에 BindGroupLayoutEntry를 넣어 유니폼이 0번 binding 슬롯으로 전달되게 한다. visibility는 어느 셰이더에서 읽을 수 있는지 정하는데, 여기선 프래그먼트 셰이더로 한정한다. BindingType은 binding 슬롯에 어떤 종류의 리소스가 입력되는지 정한다. 지금은 0번 슬롯에 어떤 종류의 리소스를 사용할지 정하는 셈이다. 유니폼 버퍼를 사용할 것이니 ty를 Uniform으로 한다. has_dynamic_offset은 하나의 버퍼에 여러 값을 담아 사용할 때 set_bind_group의 세 번째 인자로 offset을 정해 각 값을 읽을 수 있게 하는데, 지금은 필요 없다. min_binding_size는 바인딩되는 버퍼의 최소 크기를 정해 오류를 방지한다. 이것도 지금은 None으로 둬도 문제는 없다. count는 여러 리소스를 집어넣을 때 사용한다. 지금은 버퍼 하나니 None으로 둔다.
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("bind_group"),
layout: &bind_group_layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer: &global_uniform_buffer,
offset: 0,
size: None,
}),
}],
});BindGroupLayout을 이용해 BindGroup을 생성한다. entries에 이 BindGroup에서 사용할 리소스를 정한다. 0번 슬롯에 실제 버퍼, 어디부터 보여줄지 정하는 offset, 거기서부터 얼마나 보여줄지 정하는 size를 넣는다. size를 None으로 하면 버퍼 끝까지 보여준다는 의미다. offset이 0이니 지금은 버퍼 전체를 읽게 된다.
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("pipeline_layout"),
bind_group_layouts: &[Some(&bind_group_layout)],
immediate_size: 0,
});BindGroupLayout으로 PipelineLayout을 만든다. PipelineLayout은 다른 게 아니라 BindGroupLayout의 목록이다. RenderPipeline을 만들 때 애초에 어떤 그룹의 어떤 슬롯에 어떤 리소스를 사용할지 구조를 정해 만드는 것이다. 그럼 같은 구조의 BindGroup을 갈아 끼우며 사용할 수 있게 된다.
bind_group_layouts의 순번으로 각 group이 어떤 BindGroupLayout을 사용할지 정한다. immediate data는 버퍼나 BindGroup을 거치지 않고 작은 데이터를 직접 GPU로 전달하는 것이며, WGSL에서 var<immediate>로 선언해 사용할 수 있다. immediate_size는 immediate data의 최대 크기를 정한다. 지금은 사용하지 않으니 0으로 둔다.
let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("render_pipeline"),
layout: Some(&pipeline_layout),
...
});기존에 None으로 뒀던 layout에 생성한 PipelineLayout을 연결한다. None으로 두면 wgpu가 셰이더 파일을 참조해 해당 RenderPipeline의 구조를 알아서 만들어 준다. 그렇게 만들어진 자동 레이아웃으로 BindGroup을 만들 수도 있다. 이렇게 보면 지금까지 손으로 만든 과정이 무의미해 보인다. 그러나 자동으로 만들어진 BindGroupLayout은 해당 RenderPipeline에 종속되어 있다. 그래서 RenderPipeline이 교체되면 그 BindGroupLayout으로 만든 BindGroup도 사용할 수 없게 된다. 그렇기에 BindGroupLayout과 PipelineLayout을 직접 만들어 명시적으로 사용할 필요가 있다.
어째서 자동화를 제한하는지 이해가 안 되어 생각해 봤다. 자동 레이아웃은 WGSL 파일을 참고해 만들어지다 보니, WGSL 파일 내 BindGroup의 사용과 형태가 조금만 변경되어도 오류가 밖으로 역류할 가능성이 생긴다. 그렇기에 애초에 밖에서 사용을 분명히 정의하는 방향으로 설계된 것이 아닐까 싶다.
pub struct GpuState {
surface: wgpu::Surface<'static>,
device: wgpu::Device,
queue: wgpu::Queue,
config: wgpu::SurfaceConfiguration,
size: winit::dpi::PhysicalSize<u32>,
render_pipeline: wgpu::RenderPipeline,
vertex_buffer: wgpu::Buffer,
index_buffer: wgpu::Buffer,
bind_group: wgpu::BindGroup,
}Ok(GpuState {
surface: surface,
device: device,
queue: queue,
config: config,
size: size,
render_pipeline: render_pipeline,
vertex_buffer: vertex_buffer,
index_buffer: index_buffer,
bind_group: bind_group,
})render_pass.set_bind_group(0, &self.bind_group, &[]);
render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
render_pass.set_pipeline(&self.render_pipeline);
// render_pass.draw(0..6, 0..1);
render_pass.draw_indexed(0..6, 0, 0..1);BindGroup을 GpuState에 포함하고 render 메서드 내에서 set_bind_group으로 설정한다. group은 0번을 사용하며, DynamicOffset은 BindGroupLayout에서 사용하지 않기로 했기에 비워둔다.
struct GlobalUniform {
resolution: vec2f,
time: f32,
frame: u32,
}
@group(0) @binding(0)
var<uniform> global: GlobalUniform;WGSL 파일 내에 GlobalUniform 구조체를 선언하고 group 0, binding 0번 슬롯에 있는 유니폼 리소스를 GlobalUniform 구조체 global로 가져온다.
다행히도 지금은 GlobalUniform의 필드 순서가 구조체 메모리 정렬 규칙과 일치해 문제가 없다. 그러나 time이 resolution에 선행하는 경우엔 문제가 생긴다. C와 유사한 WGSL 구조체 메모리 정렬 규칙에 따라 각 필드는 자기 정렬값의 배수 위치에서 시작한다. time은 0에서 시작하고 정렬값과 크기는 4바이트다. 그 뒤 resolution은 크기와 정렬값이 모두 8바이트다. 따라서 WGSL은 resolution을 8에서 읽으려 한다.
| 타입 (Rust / WGSL) | 크기 | Rust 정렬 | WGSL 정렬 |
|---|---|---|---|
f32, u32 / f32, u32 |
4 | 4 | 4 |
[f32; 2] / vec2f |
8 | 4 | 8 |
[f32; 3] / vec3f |
12 | 4 | 16 |
[f32; 4] / vec4f |
16 | 4 | 16 |
Rust와 WGSL의 구조체 정렬 규칙은 조금 다르다. 크기는 같아도 정렬값이 달라 필드가 정렬값의 배수 위치에서 시작하는 규칙을 신경 쓸 필요가 있다. WGSL에선 패딩을 명시하지 않아도 4–7을 비우고 8에 정상적으로 배치하기에 문제는 없다. 그러나 Rust 코드의 구조체 정렬 규칙에서 문제가 생긴다. [f32; 2]는 정렬값이 4라서 time 바로 뒤인 4에서 시작한다. 그래서 8에서 시작하는 WGSL과 offset이 어긋나게 된다. 따라서 이 경우엔 time과 resolution 사이에 4바이트 패딩 필드를 명시해야 한다. 또, 구조체 크기는 가장 큰 정렬값의 배수여야 하기에 WGSL에선 frame이 16–20에 놓여 20바이트가 되고, 이를 8의 배수로 올린 24가 된다. Rust 쪽에선 가장 큰 정렬값이 4기에 20에서 끝내도 무관하지만, WGSL과 맞추기 위해 뒤에도 패딩 필드를 넣어야 한다. 그러나 지금처럼 애당초 정렬값이 큰 필드부터 배치하면 대부분의 상황에서 패딩이 필요 없어진다.
@fragment
fn fragment_main(
@builtin(position) position: vec4f,
// @location(0) uv: vec2f,
// @location(1) color: vec3f,
) -> @location(0) vec4f {
let rs = global.resolution;
let uv = position.xy / rs;
return vec4f(uv.x, uv.y, global.time, 1.0);
}resolution을 받아 각 fragment position을 나누면 0에서 1 사이의 uv를 구할 수 있다.
유니폼 업데이트
현재 유니폼 값으로 화면 해상도, 시간, 프레임을 사용하고 있다. 전부 고정되면 무의미한 값들이다. 그러니 값을 적절히 업데이트해 버퍼를 덮어써야 한다. 해상도는 창 크기가 변경될 때, 시간과 프레임은 창이 열린 뒤로 계속 변경되게 하면 된다.
pub struct GpuState {
surface: wgpu::Surface<'static>,
device: wgpu::Device,
queue: wgpu::Queue,
config: wgpu::SurfaceConfiguration,
size: winit::dpi::PhysicalSize<u32>,
render_pipeline: wgpu::RenderPipeline,
vertex_buffer: wgpu::Buffer,
index_buffer: wgpu::Buffer,
global_uniform_buffer: wgpu::Buffer,
bind_group: wgpu::BindGroup,
}
...
Ok(GpuState {
surface: surface,
device: device,
queue: queue,
config: config,
size: size,
render_pipeline: render_pipeline,
vertex_buffer: vertex_buffer,
index_buffer: index_buffer,
global_uniform_buffer: global_uniform_buffer,
bind_group: bind_group,
})let global_uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("global_uniform_buffer"),
contents: bytemuck::bytes_of(&global_uniform),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});pub fn render(&self, time: f32, frame: u32) -> anyhow::Result<RenderResult> {
...
// uniform update
let global_uniform = GlobalUniform {resolution: [self.size.width as f32, self.size.height as f32], time, frame};
self.queue.write_buffer(&self.global_uniform_buffer, 0, bytemuck::bytes_of(&global_uniform));
self.queue.submit([command_buffer]);
self.queue.present(surface_texture);
Ok(RenderResult::Done)
}우선 버퍼를 갱신할 수 있도록 GpuState에 포함시키고, 버퍼로 데이터를 복사해 넣어 다시 쓸 수 있도록 BufferUsages::COPY_DST를 추가한다. 이후 render의 입력으로 각 값을 받아 write_buffer로 덮어쓴다. resolution은 따로 입력받지 않는다. GpuState가 창 크기가 변할 때 업데이트되는 size를 이미 가지고 있기 때문이다.
fn render(&self, event_loop: &ActiveEventLoop, time: f32, frame: u32) {
if let Some(state) = &self.gpu_state {
match state.render(time, frame) {
Ok(RenderResult::Done) => {
event_loop.set_control_flow(ControlFlow::Wait);
if let Some(window) = &self.window {
window.request_redraw();
}
}
Ok(RenderResult::Retry) => {
let deadline = Instant::now() + Duration::from_millis(200);
event_loop.set_control_flow(ControlFlow::WaitUntil(deadline));
}
Err(err) => {
eprintln!("{err}: App.render 실패");
event_loop.exit();
}
}
}
}App의 메서드로 묶어 놓은 render 또한 각 유니폼을 입력받게 한다. RenderResult가 Done일 때 request_redraw를 호출해 창 크기 변경 등의 이벤트 외에도 창이 다시 그려지게 한다. time과 frame을 업데이트하기 위함이다.
pub struct App {
window: Option<Arc<Window>>,
gpu_state: Option<GpuState>,
start: Option<Instant>,
}
impl App {
pub fn new() -> Self {
App {
window: None,
gpu_state: None,
start: None,
}
}
...
}match gpu_state {
Ok(state) => {
self.gpu_state = Some(state);
self.start = Some(Instant::now());
if let Some(window) = &self.window {
window.request_redraw();
}
}
Err(err) => {
eprintln!("{err}: GpuState 생성 실패");
event_loop.exit();
}
}App에 start 필드를 추가한다. 애플리케이션이 시작될 때의 Instant를 now로 받기 위함이다.
const FPS: f32 = 60.0;
...
WindowEvent::RedrawRequested => {
if let Some(start) = self.start {
let frame = (start.elapsed().as_secs_f32() * FPS) as u32;
let time = frame as f32 / FPS;
self.render(event_loop, time, frame);
}
}일단 FPS(Frames Per Second)를 상수로 선언하고, RedrawRequested 이벤트에서 frame과 time을 계산해 입력하면 된다. 초당 프레임은 프레임 ÷ 초(경과 시간)니 현재 프레임 번호는 초당 프레임(FPS) × 초(경과 시간)이다. 소수점은 버려 정수로 만든다. Instant의 elapsed 메서드는 now로 얻은 시작 시간으로부터 흐른 시간을 반환한다. time은 경과 시간을 그대로 사용할 수도 있지만, frame 번호로 접근 가능하게 frame을 FPS로 나눈 값을 사용한다.
@fragment
fn fragment_main(
@builtin(position) position: vec4f,
// @location(0) uv: vec2f,
// @location(1) color: vec3f,
) -> @location(0) vec4f {
let time = global.time;
let rs = global.resolution;
let uv = position.xy / rs;
return vec4f(uv.x, uv.y, sin(time) * 0.5 + 0.5, 1.0);
}프래그먼트 셰이더의 출력 색상으로 time을 이용해 0부터 1 사이를 왕복하는 값을 사용해 본다.
키보드 제어
지금은 애플리케이션이 시작되고 render가 완료되어 request_redraw가 호출되면 RedrawRequested 이벤트에서 time과 frame이 증가한다. 키보드 입력으로 이를 제어할 수 있게 한다. 스페이스바는 재생과 정지, 멈춘 상태에서 →, ←는 한 프레임 이동, Shift + ←, →는 10프레임 이동, Cmd(맥 기준) + ←는 첫 프레임으로 돌아가게 할 것이다.
enum PlaybackState {
Playing{base: u32, start: Instant},
Paused{base: u32},
}재생과 일시정지 상태를 enum으로 선언한다. 그저 redraw만 멈춘다면, 예를 들어 2초 재생되다 1초 멈추고 다시 재생될 때, 화면이 2초의 프레임이 아니라 3초의 프레임부터 재생되기 시작한다. 이를 방지하려면 화면을 멈출 때 어디까지 진행됐는지 알고 있어야 한다. 다시 재생할 땐 멈춘 프레임부터의 경과 시간을 다시 측정하면 된다.
pub struct App {
window: Option<Arc<Window>>,
gpu_state: Option<GpuState>,
playback_state: PlaybackState,
}
impl App {
pub fn new() -> Self {
App {
window: None,
gpu_state: None,
playback_state: PlaybackState::Paused { base: 0 },
}
}
...
}Ok(state) => {
self.gpu_state = Some(state);
if let Some(window) = &self.window {
self.playback_state = PlaybackState::Playing { base: 0, start: Instant::now() };
window.request_redraw();
}
},App에 시작 시간 대신 PlaybackState를 포함시킨다. 애플리케이션이 시작하면 상태를 Playing으로 변경한다.
Ok(RenderResult::Done) => {
event_loop.set_control_flow(ControlFlow::Wait);
if let Some(window) = &self.window {
if let PlaybackState::Playing { .. } = self.playback_state {
window.request_redraw();
}
}
},WindowEvent::RedrawRequested => {
let frame = match self.playback_state {
PlaybackState::Paused { base } => {
base
},
PlaybackState::Playing { base, start } => {
base + (start.elapsed().as_secs_f32() * FPS) as u32
},
};
let time = frame as f32 / FPS;
self.render(event_loop, time, frame);
},재생 중일 때만 request_redraw를 호출하게 하고, RedrawRequested 시 App의 playback_state에 따라 frame을 구한다. 재생되고 있다면 base(재생을 시작한 시점의 프레임)에 경과 시간 × FPS, 즉 프레임을 더하고, 멈춰 있다면 base(멈춘 시점의 프레임)가 frame이 된다.
이제 멈춰 있는 동안엔 RedrawRequested가 더 오지 않는다. 그래서 멈춘 상태에서 무언가 바꿀 땐(다시 재생, 프레임 이동) request_redraw를 직접 불러야 한다.
// util.rs
use std::time::Instant;
const FPS: f32 = 60.0;
pub fn frame_at(base: u32, start: Instant) -> u32 {
base + (start.elapsed().as_secs_f32() * FPS) as u32
}
pub fn time_at(base: u32) -> f32 {
base as f32 / FPS
}
// main.rs
mod util;
// app.rs
use crate::util::{frame_at, time_at};반복되는 구문은 함수로 묶어 util 모듈로 분리한다. 다른 파일에서 쓸 수 있게 함수에 pub을 붙이고, main.rs에 mod util로 등록한 뒤 app.rs에서 use로 가져온다. FPS는 util 안에서만 쓰기에 pub을 붙이지 않았다.
WindowEvent::Occluded(false) => {
let frame = match self.playback_state {
PlaybackState::Paused { base } => base,
PlaybackState::Playing { base, start } => frame_at(base, start),
};
let time = time_at(frame);
self.render(event_loop, time, frame);
},render를 부르는 곳은 두 군데 더 있다. 창이 가려졌다 다시 보일 때(Occluded(false))와 렌더를 다시 시도할 때(new_events)다. 앞서 이 두 곳엔 time과 frame에 0을 넣었는데, 그러면 다시 보이는 순간 첫 프레임이 그려진다. 여기서도 재생 상태에 따라 frame을 구한다.
if logical_key == winit::keyboard::NamedKey::Space
&& state == winit::event::ElementState::Pressed
&& repeat == false
{
match self.playback_state {
PlaybackState::Playing { base, start } => {
self.playback_state = PlaybackState::Paused {
base: frame_at(base, start)
}
},
PlaybackState::Paused { base } => {
self.playback_state = PlaybackState::Playing {
base, start: Instant::now()
};
if let Some(window) = &self.window {
window.request_redraw();
};
},
}
}KeyboardInput 이벤트에서 스페이스바가 눌리면 PlaybackState를 변경한다. 다시 재생할 땐 현재 프레임을 base로, 새로운 시점을 start로 정한다. 화면을 멈출 때는 base, 즉 마지막 Playing 시점의 프레임에 start의 elapsed, 즉 경과 시간만큼의 프레임을 더해 base를 다시 정한다.
if logical_key == winit::keyboard::NamedKey::ArrowRight
&& state == winit::event::ElementState::Pressed
{
if let PlaybackState::Paused { base } = self.playback_state {
self.playback_state = PlaybackState::Paused { base: base + 1 };
if let Some(window) = &self.window {
window.request_redraw();
};
}
}
if logical_key == winit::keyboard::NamedKey::ArrowLeft
&& state == winit::event::ElementState::Pressed
{
if let PlaybackState::Paused { base } = self.playback_state {
self.playback_state = PlaybackState::Paused { base: base.saturating_sub(1) };
if let Some(window) = &self.window {
window.request_redraw();
};
}
}멈춰 있을 때 ←, → 키로 프레임을 이동시킬 수 있게 한다. u32는 0 미만이 되면 프로그램을 터트린다. 따라서 0 아래로 내려가지 않게 하는 saturating_sub을 사용한다.
fn sdCircle(p: vec2f, r: f32) -> f32 {
return length(p) - r;
}
@fragment
fn fragment_main(
@builtin(position) position: vec4f,
// @location(0) uv: vec2f,
// @location(1) color: vec3f,
) -> @location(0) vec4f {
let time = global.time;
let rs = global.resolution;
let aspect = rs / min(rs.x, rs.y);
let uv = (position.xy / rs - 0.5) * 2.0 * aspect;
var circle = sdCircle(uv, sin(time) * 0.5 + 0.5);
circle = smoothstep(-0.001, 0.001, circle);
let color = vec3f(circle);
return vec4f(color, 1.0);
}프레임 변화를 직관적으로 볼 수 있도록 시간에 따라 크기가 조정되는 원을 그리게 한다.
use std::collections::HashSet;
pub struct App {
window: Option<Arc<Window>>,
gpu_state: Option<GpuState>,
playback_state: PlaybackState,
pressed_keys: HashSet<winit::keyboard::PhysicalKey>,
}
impl App {
pub fn new() -> Self {
App {
window: None,
gpu_state: None,
playback_state: PlaybackState::Paused { base: 0 },
pressed_keys: HashSet::new(),
}
}
...
}키 동시 입력을 처리하기 위해 HashSet을 이용한다. HashSet은 값을 중복 없이 담아 두는 모음이다. 벡터나 배열과 달리 순서가 없고, 어떤 값이 들어 있는지를 빠르게 확인하는 데 쓴다. 따라서 어떤 키가 Press될 때 그 키를 HashSet에 집어넣고 Release될 때 뺀다면, HashSet 안에 든 키들로 동시 입력을 처리할 수 있게 된다. App이 HashSet도 들고 있게 한다.
WindowEvent::KeyboardInput { event, .. } => {
...
let physical_key = event.physical_key;
...
match state {
winit::event::ElementState::Pressed => {
self.pressed_keys.insert(physical_key);
},
winit::event::ElementState::Released => {
self.pressed_keys.remove(&physical_key);
},
}
if self.pressed_keys.contains(&PhysicalKey::Code(KeyCode::ArrowLeft))
&& self.pressed_keys.contains(&PhysicalKey::Code(KeyCode::SuperLeft))
{
match self.playback_state {
PlaybackState::Playing { .. } => {
self.playback_state = PlaybackState::Playing {
base: 0,
start: Instant::now(),
}
},
PlaybackState::Paused { .. } => {
self.playback_state = PlaybackState::Paused {
base: 0,
};
if let Some(window) = &self.window {
window.request_redraw();
};
},
}
}
},입력으로는 PhysicalKey를 사용한다. logical_key는 실제 입력값이라 Shift와 함께 누르면 키 값이 바뀐다. 한·영 전환 때도 같은 문제가 생긴다. PhysicalKey는 키보드 자리를 기준으로 하기에 이런 변동이 없다. 키가 눌리면 값들을 HashSet에 insert하고, 손을 떼면 remove한다. 그리고 ←와 왼쪽 Cmd가 함께 HashSet에 들어 있는지 contains로 확인해 프레임을 초기화한다. 재생 중이면 재생 상태를 유지하며 처음으로, 멈춰 있으면 그 상태에서 처음으로 돌아오게 했다. 양쪽 Cmd 키 모두 적용하면 사용성에 비해 코드가 길어져 왼쪽 Cmd만 적용했다.
if state == winit::event::ElementState::Pressed {
// Cmd + ←: 처음으로
...
if self.pressed_keys.contains(&PhysicalKey::Code(KeyCode::ArrowLeft))
&& !self.pressed_keys.contains(&PhysicalKey::Code(KeyCode::ShiftLeft))
{
if let PlaybackState::Paused { base } = self.playback_state {
self.playback_state = PlaybackState::Paused { base: base.saturating_sub(1) };
if let Some(window) = &self.window {
window.request_redraw();
};
}
} else if self.pressed_keys.contains(&PhysicalKey::Code(KeyCode::ArrowRight))
&& !self.pressed_keys.contains(&PhysicalKey::Code(KeyCode::ShiftLeft))
{
if let PlaybackState::Paused { base } = self.playback_state {
self.playback_state = PlaybackState::Paused { base: base + 1 };
if let Some(window) = &self.window {
window.request_redraw();
};
}
}
if self.pressed_keys.contains(&PhysicalKey::Code(KeyCode::ArrowLeft))
&& self.pressed_keys.contains(&PhysicalKey::Code(KeyCode::ShiftLeft))
{
if let PlaybackState::Paused { base } = self.playback_state {
self.playback_state = PlaybackState::Paused { base: base.saturating_sub(10) };
if let Some(window) = &self.window {
window.request_redraw();
};
}
} else if self.pressed_keys.contains(&PhysicalKey::Code(KeyCode::ArrowRight))
&& self.pressed_keys.contains(&PhysicalKey::Code(KeyCode::ShiftLeft))
{
if let PlaybackState::Paused { base } = self.playback_state {
self.playback_state = PlaybackState::Paused { base: base + 10 };
if let Some(window) = &self.window {
window.request_redraw();
};
}
}
}같은 원리로 왼쪽 Shift를 누르고 화살표를 누르면 앞뒤로 10프레임씩 이동하게 했다. 11프레임씩 이동되지 않게 한 프레임 이동도 HashSet으로 옮기고, Shift가 눌려 있지 않을 때만 실행되게 조건을 나눴다. 또 HashSet을 확인하는 조건은 키를 뗄 때도 실행된다. 예를 들어 Shift + →를 누른 채로 다른 키를 떼면 그때도 10프레임 움직인다. 그래서 전체를 Pressed일 때만 실행되게 감쌌다.
브라우저를 통해 렌더할 땐 이런 기능을 구현할 생각 자체를 못 했다. 운영체제 창엔 기능 구현 관점에 영향을 끼치는 오묘한 힘이 있는 듯하다. 예전에 정말 이 기능이 필요 없어 생각조차 못 했던 것인지 더는 기억도 안 난다.
다음 글로 이어집니다.


