셰이더 드로잉: 환경 07

이전 글에서 이어집니다.

자동 새로고침

별도의 키 입력 이벤트 없이 WGSL 파일이 편집되면 셰이더 코드를 자동으로 다시 읽게 하고 싶다. 운영체제는 파일이 변경되면 알림을 보내는데, 이 알림은 notify라는 Rust 라이브러리로 받아올 수 있다.

한 줄씩 실행되는 프로그램의 흐름을 스레드(Thread)라고 한다. 프로그램의 가장 큰 줄기, 즉 현재 main 함수를 엔트리 포인트 삼아 진행되는 흐름은 메인 스레드(Main Thread)다. 현재 프로그램은 winit을 통한 EventLoop를 반복하다 exit 메서드로 빠져나온다. 즉 이 흐름이 현 프로그램의 메인 스레드다.

내가 빨래를 하는 동시에 요리를 할 수 없듯 프로그램 또한 여러 작업을 한 스레드에서 몽땅 수행할 수 없다. 인내를 필요로 하는 일에 여러 스레드가 필요한 까닭이다. 또, 여러 스레드를 사용한다 해도 한쪽 작업이 다른 쪽 작업에 직접 개입하면 안 된다. 다른 쪽 작업의 결과를 의도치 않게 망칠 수 있기 때문이다. 섬유유연제로 만들어진 음식은 세상에 존재해선 안 된다. 그렇기에 기본적으로 Rust는 스레드끼리 서로의 값을 바꾸는 것을 컴파일 단계부터 금한다. 한쪽 스레드의 결과를 다른 쪽 값에 반영하기 위해선 보다 섬세한 접근이 필요하다.

notify는 파일 변경을 감지하는 별도의 스레드를 운용한다. 메인 스레드가 이벤트 루프를 돌리며 파일 변경 알림까지 기다릴 수 없기 때문이다. 앞서 이야기했듯 스레드끼리 서로의 값을 바로 변경할 수 없다. 그렇기에 notify의 파일 감시 결과를 winit의 이벤트 루프 입력으로 받게 한다. 마치 키가 눌렸을 때 이벤트 콜백이 실행되게 하듯 winit API에 부합하는 형태로 받아오는 셈이다. 현재 ApplicationHandler trait으로 제공되는 window_event 메서드는 말 그대로 창과 연관된 이벤트를 받아온다. 따라서 내가 원하는 별도 이벤트를 받아오게 하려면 user_event라는 별도의 메서드를 사용해야 한다.

user_event는 세 번째 인자로 WindowEvent가 아닌 사용자 정의 타입 이벤트를 받아온다. 이때, 커스텀 이벤트를 전달하는 매개가 EventLoopProxy다. EventLoopProxy는 EventLoop의 create_proxy로 만든다. 이 EventLoopProxy의 send_event로 사용자 정의 타입 이벤트를 보내면, 해당 EventLoop의 user_event가 이를 세 번째 인자로 받는다. 이를 위해 EventLoop부터 new 연관 함수 대신 with_user_event로 사용자 정의 타입 이벤트를 포함해 생성할 필요가 있다. 그리고 ApplicationHandler는 현재 () 타입 제네릭을 기본으로 사용 중인데, 여기에도 사용할 이벤트 타입을 기입하면 된다. ApplicationHandler의 제네릭 타입과 EventLoop의 제네릭 타입이 불일치하면 컴파일 오류가 발생한다.

pub enum UserEvent {
    ShaderChanged,
}

사용자 정의 이벤트는 UserEvent enum으로 정의한다. variant는 ShaderChanged 하나. 이후 필요할 때 추가하도록 한다.

let event_loop = EventLoop::<UserEvent>::with_user_event()
    .build()
    .expect("EventLoop 생성 실패");

with_user_event로 내가 정의한 타입을 포함해 EventLoop를 빌드한다. ::<>는 제네릭 타입을 정하는 문법인데 터보피시(Turbofish)라 불린다. ::가 꼬리, <>가 머리다. 무척 귀엽다.

impl ApplicationHandler<UserEvent> for App {
    ...
    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: UserEvent) {

    }
}

이쪽에도 제네릭 타입을 기입하면 된다. 이제 내가 정한 타입의 이벤트를 user_event로 받을 준비가 끝났다.

파일 감시

notify의 사용엔 크게 두 단계가 있다. 우선 recommended_watcher에 파일 변경 알림이 오면 실행할 동작을 넘기면, 운영체제에 맞는 watcher를 반환한다. 그다음 watch에 경로와 RecursiveMode를 입력해 해당 경로를 감시하도록 한다. 경로는 생성할 때가 아니라 나중에 등록하기 때문에, 하나의 watcher에 여러 경로를 등록할 수도 있다. RecursiveMode는 하위 폴더까지 볼지, 혹은 해당 폴더만 볼지 정한다.

fn main() {
    ...
    let proxy = event_loop.create_proxy();
    let shader_path = match std::env::args().nth(1) {
        Some(path) => std::fs::canonicalize(path).expect("절대 경로 인식 실패"),
        None => {
            eprintln!("Shader 경로 미입력: cargo run -- []");
            return
        },
    };
    let watch_path = shader_path.clone();
    ...
}

EventLoopProxy를 생성한다. 제네릭 타입은 UserEvent가 된다. 셰이더 경로는 canonicalize를 사용해 절대 경로로 받는다. recommended_watcher는 notify 스레드에서 작동하는 클로저를 입력받는다. 따라서 클로저 내에서 사용될 요소들은 move 키워드로 소유권을 넘겨줘야 한다. 셰이더 경로 또한 클로저 내부에서 사용할 예정인데, 이후 App에도 넘겨줘야 하기에 clone 메서드로 복사본을 만든다.

fn main() {
    ...
    let mut watcher = notify::recommended_watcher(move |res: Result<Event>| {
        match res {
            Ok(event) => {
                if event.paths.contains(&watch_path)
                    && !matches!(event.kind, EventKind::Modify(ModifyKind::Metadata(..)))
                {
                    if let Err(err) = proxy.send_event(UserEvent::ShaderChanged) {
                        eprintln!("proxy: {err}")
                    }
                    println!("{:?}", event.kind);
                }
            },
            Err(err) => eprintln!("watcher: {err}"),
        }
    }).expect("watcher: 생성 실패");

    watcher
        .watch(&shader_path.parent().expect("부모 폴더 발견 실패"), RecursiveMode::NonRecursive)
        .expect("watcher: watch 등록 실패");
    ...
}

notify는 알림이 올 때마다 Result<Event>를 인자로 입력해 클로저를 실행시킨다. Event는 notify가 받는 알림(이벤트)의 내용을 담은 구조체다. 이를 통해 EventKind를 알아낼 수 있는데, 내 환경(macOS, VS Code)에서는 저장할 때마다 이벤트가 두 번 발생한다. 한 번은 파일 내용 변경, 한 번은 파일 정보(최종 수정 시각 등으로 추정) 변경이다. 저장 한 번에 이벤트가 두 번 발생하면 클로저 또한 두 번 실행된다. 따라서 이벤트 경로에 셰이더 파일이 있고 파일 내용이 바뀐 경우에만 send_event로 UserEvent::ShaderChanged를 전송하게 한다.

생성된 RecommendedWatcher의 watch 메서드로 셰이더 파일 부모 경로와 RecursiveMode를 정해 감시 경로를 등록한다. 셰이더 파일이 아니라 부모 경로를 등록한 데는 이유가 있다. notify 문서에 따르면 편집기마다 저장 방식이 다르다. 어떤 편집기는 원본 파일을 고쳐 쓰지 않고 새 파일을 만들어 기존 파일과 바꿔치기한다. 이렇게 교체된 파일은 감시 대상에서 벗어날 수 있으니, 파일 자체보다 파일이 든 폴더를 감시하는 편이 안전하다. 또, 이미 Cmd + R 새로고침이 있으니 watcher를 Option으로 둘지, 즉, 파일 감시 체계가 프로그램의 필수 요소인지 고민하다 필수로 두기로 결정했다.

// fn watch_start(
//     path: &std::path::Path,
//     proxy: EventLoopProxy<UserEvent>
// ) -> anyhow::Result<RecommendedWatcher> {
//     let shader_path = path.to_path_buf();
//     let parent_path = path.parent().context("watcher: 부모 폴더 찾지 못함")?;
//     let mut watcher = notify::recommended_watcher(move |res: Result<Event>| {
//         match res {
//             Ok(event) => {
//                 if event.paths.contains(&shader_path) {
//                     if let Err(err) = proxy.send_event(UserEvent::ShaderChanged){
//                         eprintln!("{err}: UserEvent::ShaderChanged")
//                     }
//                     println!("{:?}", event.kind)
//                 }
//             },
//             Err(err) => {
//                 eprintln!("{err}")
//             },
//         }
//     })?;
//     watcher.watch(parent_path, RecursiveMode::NonRecursive)?;
//     Ok(watcher)
// }

Option으로 사용하는 함수도 만들었는데, 일단 글에만 남겨 두고 프로젝트 파일에서는 지운다.

impl App {
    ...
    fn reload_shader(&mut self) -> () {
        if let Some(state) = &mut self.gpu_state {
            let shader_code = match std::fs::read_to_string(&self.shader_path) {
                Ok(code) => code,
                Err(err) => {
                    eprintln!("{err}");
                    return
                }
            };
            match pollster::block_on(state.reload_shader(shader_code)) {
                Ok(()) => {
                    if let Some(window) = &self.window {
                        window.request_redraw();
                    };
                },
                Err(err) => {
                    eprintln!("{err}");
                },
            }
        }
    }
}

키보드 입력 이벤트와 user_event 두 곳에서 같은 코드가 필요한 셈이니 메서드로 만든다. 자동 새로고침을 표준으로 결정한 김에 키보드 입력 새로고침은 없애버릴까 고민하다 차후 API 확장 시 정하기로 하고 일단 남겨둔다.

impl ApplicationHandler<UserEvent> for App {
    ...
    fn user_event(&mut self, _event_loop: &ActiveEventLoop, event: UserEvent) {
        match event {
            UserEvent::ShaderChanged => {
                self.reload_shader();
            },
            // _ => {},
        }
    }
}

user_event에서 EventLoopProxy를 통해 ShaderChanged가 전달되면 파이프라인을 재조립한다.

다음 글로 이어집니다.