셰이더 드로잉: 환경 09

이전 글에서 이어집니다.

CLI

지금 프로그램은 창을 띄운 뒤 Cmd + S를 누르면 화면을 PNG로 저장한다. 이걸로 120장의 이미지 흐름을 저장하려면 Cmd + S를 120번 눌러야 한다. 그런 일이 생기지 않도록 창 없이도 원하는 범위를 출력하는 기능을 추가할 것이다. 지금은 args로 경로를 입력받아 창을 띄운다. args로 창 명령과 출력 명령을 나눠 받으려면 여러 인자와 옵션을 직접 파싱해야 한다. clap은 입력받을 명령줄을 정하고 잘못된 입력 시 오류 출력을 도와주는 라이브러리다. clap tutorial을 살펴보면 사용 방법을 알 수 있다.

cargo add clap --features derive
use std::path::PathBuf;
use clap::{Parser, Subcommand, value_parser};

#[derive(Parser)]
pub struct Cli {
    #[command(subcommand)]
    pub command: Command,
}

#[derive(Subcommand)]
pub enum Command {
    Window {
        path: PathBuf,
    },
    Export {
        path: PathBuf,
        #[arg(long, default_value_t = 720, value_parser = value_parser!(u32).range(1..))]
        width: u32,
        #[arg(long, default_value_t = 720, value_parser = value_parser!(u32).range(1..))]
        height: u32,
        #[arg(long, default_value_t = 0)]
        frame: u32,
        #[arg(long, default_value_t = 60, value_parser = value_parser!(u32).range(1..))]
        fps: u32,
    },
}

clap을 추가하고 명령줄 파싱 구조를 만든다. 구조체에 #[derive(Parser)]로 Parser trait을 붙이고, #[derive(Subcommand)]로 명령 enum을 정의한다. Cli의 필드에 #[command(subcommand)]를 붙여 명령 enum을 받게 한다.

window 명령에선 기존 args 입력처럼 셰이더 파일 경로만 있으면 된다. 반면 export는 출력할 크기와 프레임, 그리고 FPS를 입력받아야 한다. 명령의 필드로 각 입력을 정의할 수 있다. long은 --width 720처럼 해당 필드명으로 입력받을 수 있게 해준다. default_value_t는 필드의 타입으로 기본값을 정한다. 명령줄로 필드 값을 입력하지 않으면 기본값이 사용된다. value_parser는 입력을 검사한다. value_parser!로 원하는 타입과 범위 등을 검사할 수 있다.

fn main() {
    let cli = Cli::parse();
    match cli.command {
        Command::Window { path } => {
            //window 실행
        },
        Command::Export { path, width, height, frame, fps } => {
            //export 실행
        },
    }
    ...
}

parse로 실행 시 입력한 명령줄 인자를 파싱해 사용한다.

fn main() {
    let cli = Cli::parse();
    match cli.command {
        Command::Window { path } => {
            let event_loop = EventLoop::<UserEvent>::with_user_event()
            .build()
            .expect("EventLoop 생성 실패");
        
            let proxy = event_loop.create_proxy();

            let shader_path = std::fs::canonicalize(path).expect("절대 경로 인식 실패");
            let watch_path = shader_path.clone();

            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 등록 실패");

            let mut app = App::new(shader_path);
            event_loop.run_app(&mut app).expect("어플리케이션 실행 실패");
        },
        Command::Export { path, width, height, frame, fps } => {
            println!("{:?}, {}×{}, {}, {}", path, width, height, frame, fps);
        },
    }
}

기존 창 실행 부분을 window 명령에 할당하고, args 대신 입력받는 path를 사용하도록 만든다. export 시에는 일단 각 입력값을 터미널에 출력하게 한다.

cargo run -- window [경로]

window 명령 실행 시 기존과 동일하게 작동한다.

$ cargo run -- export sketches/shader.wgsl
"sketches/shader.wgsl", 720×720, 0, 60

export 명령 실행 시 각 입력값이 터미널에 출력된다. 미입력 시 default_value_t로 정한 값이 사용된다.

창, 출력 분리

지금 GpuState는 Window를 입력받아 생성된다. export 명령엔 창이 불필요하기에 지금의 구조를 Viewer와 Gpu로 분리할 것이다. Gpu는 창, 구체적으로 Surface와 무관한 요소를 가진다. Viewer는 Gpu를 포함하며, 창과 관련된 요소를 가진다. 현재 창과 관련된 필드는 surface, config, size, render_pipeline이다. 전부 Surface, 혹은 SurfaceConfiguration과 관련된 요소들이다. 나머지는 Gpu가 가지면 된다.

메서드 또한 마찬가지다. resize, size, render, reload_shader 등 창과 관련된 것들은 Viewer에, 나머지는 Gpu에 옮기면 된다. 이후 window 명령에선 Viewer를, export 명령에선 Gpu만 사용한다.

pub struct Gpu {
    adapter: wgpu::Adapter,
    device: wgpu::Device,
    queue: wgpu::Queue,
    vertex_buffer: wgpu::Buffer,
    index_buffer: wgpu::Buffer,
    global_uniform_buffer: wgpu::Buffer,
    bind_group: wgpu::BindGroup,
    pipeline_layout: wgpu::PipelineLayout,
    export_pipeline: wgpu::RenderPipeline,
}

impl Gpu {
    pub async fn new(
        instance: wgpu::Instance,
        surface: Option<&wgpu::Surface<'static>>,
        shader_code: &str,
    ) -> anyhow::Result<Self> {
        let adapter = instance.request_adapter(&wgpu::RequestAdapterOptions {
            compatible_surface: surface,
            ..Default::default()
        }).await.context("Adapter 요청 실패")?;

        let (device, queue) = adapter.request_device(&wgpu::wgt::DeviceDescriptor {
            required_limits: adapter.limits(),
            ..Default::default()
        }).await.context("Device 요청 실패")?;

        let vertices = [
            Vertex::new([-1.0, -1.0], [0.0, 0.0], [1.0, 0.0, 0.0]),
            Vertex::new([1.0, -1.0], [1.0, 0.0], [0.0, 1.0, 0.0]),
            Vertex::new([1.0, 1.0], [1.0, 1.0], [0.0, 0.0, 1.0]),
            Vertex::new([-1.0, 1.0], [0.0, 1.0], [1.0, 1.0, 1.0]),
        ];
        let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("vertex_buffer"),
            contents: bytemuck::cast_slice(&vertices),
            usage: wgpu::BufferUsages::VERTEX,
        });

        let indices: [u16; 6] = [0, 1, 2, 0, 2, 3];
        let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("index_buffer"),
            contents: bytemuck::cast_slice(&indices),
            usage: wgpu::BufferUsages::INDEX,
        });

        let global_uniform = GlobalUniform {
            resolution: [0.0, 0.0],
            frame: 0,
            time: 0.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 | wgpu::BufferUsages::COPY_DST,
        });

        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,
            }],
        });
        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,
                }),
            }],
        });

        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("pipeline_layout"),
            bind_group_layouts: &[Some(&bind_group_layout)],
            immediate_size: 0,
        });
        let export_pipeline = create_render_pipeline(
            &device,
            &pipeline_layout,
            wgpu::TextureFormat::Rgba8UnormSrgb,
            shader_code,
        ).await?;

        Ok(Gpu {
            adapter,
            device,
            queue,
            vertex_buffer,
            index_buffer,
            global_uniform_buffer,
            bind_group,
            pipeline_layout,
            export_pipeline,
        })
    }

    fn draw_to(...) -> anyhow::Result<wgpu::SubmissionIndex> { ... }

    pub fn render_to_bytes(...) -> anyhow::Result<Vec<u8>> { ... }
}

분리된 Gpu 구조체와 생성 함수. Adapter와 Surface는 같은 Instance로부터 생성되어야 한다. 따라서 Gpu 생성 시 Instance를 입력받게 한다. 그리고 Surface에 그릴 수 있는 장치를 요청해야 하기에, Adapter 요청 시 compatible_surface의 입력으로 Surface를 사용해야 한다. 하지만 Gpu는 Surface를 가지지 않기에 Option으로 입력받아 Adapter를 요청하게 한다. 이렇게 하면 Viewer 생성 시 Surface를 입력하고, Gpu 단독 사용 시 None을 입력해 사용할 수 있게 된다.

pub struct Viewer {
    surface: wgpu::Surface<'static>,
    config: wgpu::SurfaceConfiguration,
    size: winit::dpi::PhysicalSize<u32>,
    render_pipeline: wgpu::RenderPipeline,
    pub gpu: Gpu,
}

impl Viewer {
    pub async fn new(
        window: Arc<Window>,
        shader_code: &str,
    ) -> anyhow::Result<Self> {
        let size = window.inner_size();

        let instance = wgpu::Instance::default();
        let surface = instance.create_surface(window)?;
        let gpu = Gpu::new(instance, Some(&surface), shader_code)
            .await.context("Gpu 생성 실패")?;

        let config = surface
            .get_default_config(&gpu.adapter, size.width, size.height)
            .ok_or_else(|| anyhow!("호환되는 SurfaceConfig 찾지 못함"))?;
        if size.width > 0 && size.height > 0 {
            surface.configure(&gpu.device, &config);
        }

        let render_pipeline = create_render_pipeline(
            &gpu.device,
            &gpu.pipeline_layout,
            config.format,
            shader_code,
        ).await.context("Viewer: render_pipeline 생성 실패")?;

        Ok(Viewer {
            surface,
            config,
            size,
            render_pipeline,
            gpu,
        })
    }

    pub fn render(...) -> anyhow::Result<RenderResult> { ... }

    pub async fn reload_shader(...) -> anyhow::Result<()> { ... }

    pub fn resize(...) { ... }

    pub fn size(&self) -> (u32, u32) { ... }
}

Viewer 생성 시 기존 GpuState와 동일하게 Window와 셰이더 코드를 입력받아 Instance와 Surface, 그리고 내부 Gpu를 생성하면 된다.

각 메서드 또한 정리한다. Gpu의 draw_to를 render(화면 출력)와 render_to_bytes(파일 출력)에서 함께 사용하는 구조다. 차이는 그릴 TextureView가 Surface에서 오는지, 빈 Texture에서 오는지, 그리고 그린 뒤 결과를 어떻게 처리하는지뿐이다.

@@ use @@
-use crate::gpu::{GpuState, RenderResult};
+use crate::gpu::{Viewer, RenderResult};

@@ struct App @@
-gpu_state: Option<GpuState>,
+viewer: Option<Viewer>,

@@ App::new @@
-gpu_state: None,
+viewer: None,

@@ App::render @@
-if let Some(state) = &self.gpu_state {
-    match state.render(frame, time) {
+if let Some(viewer) = &self.viewer {
+    match viewer.render(frame, time) {

@@ App::reload_shader @@
-if let Some(state) = &mut self.gpu_state {
+if let Some(viewer) = &mut self.viewer {
 ...
-    match pollster::block_on(state.reload_shader(&shader_code)) {
+    match pollster::block_on(viewer.reload_shader(&shader_code)) {

@@ resumed @@
-let gpu_state = block_on(GpuState::new(window.clone(), &shader_code));
-match gpu_state {
-    Ok(state) => {
-        self.gpu_state = Some(state);
+match block_on(Viewer::new(window.clone(), &shader_code)) {
+    Ok(viewer) => {
+        self.viewer = Some(viewer);

@@ WindowEvent::Resized @@
-if let Some(state) = &mut self.gpu_state {
-    state.resize(size.width, size.height);
+if let Some(viewer) = &mut self.viewer {
+    viewer.resize(size.width, size.height);

@@ Cmd+S 저장 @@
-if let Some(gpu) = &self.gpu_state {
+if let Some(viewer) = &self.viewer {
 ...
-    let (width, height) = gpu.size();
+    let (width, height) = viewer.size();
 ...
-    let bytes = match gpu.render_to_bytes(width, height, frame, time) {
+    let bytes = match viewer.gpu.render_to_bytes(width, height, frame, time) {

창을 생성해 GpuState를 사용하던 기존 코드를 Viewer를 사용하도록 바꿔준다. 단순히 코드를 새로운 구조에 맞추는 것뿐이니 이 이상의 변화는 굳이 담지 않는다.

명령줄 PNG 출력

이제 window 명령 쪽의 작동을 확인했다면 export 명령이 작동하도록 코드를 작성하면 된다.

fn main() {
    let cli = Cli::parse();
    match cli.command {
        Command::Window { path } => {
            ...
        },
        Command::Export { path, width, height, frame, fps } => {
            let shader_code = match std::fs::canonicalize(&path) {
                Ok(path) => {
                    match std::fs::read_to_string(&path) {
                        Ok(code) => code,
                        Err(err) => {
                            eprintln!("{err}: {path:?}");
                            std::process::exit(1)
                        },
                    }
                },
                Err(err) => {
                    eprintln!("{err}: {path:?}");
                    std::process::exit(1)
                },
            };

            let instance = wgpu::Instance::default();
            let gpu = pollster::block_on(Gpu::new(instance, None, &shader_code)).expect("Gpu 생성 실패");

            let time = frame as f32 / fps as f32;
            let bytes = match gpu.render_to_bytes(width, height, frame, time) {
                Ok(bytes) => bytes,
                Err(err) => {
                    eprintln!("{err}");
                    std::process::exit(1)
                },
            };

            let file_name = format!("out_{:04}.png", frame);
            let output_path = std::path::Path::new("outputs").join(file_name);
            match save_png(&output_path, width, height, &bytes) {
                Ok(()) => {
                    println!("{output_path:?}")
                },
                Err(err) => {
                    eprintln!("{err}");
                    std::process::exit(1)
                },
            }
        },
    }
}

입력받은 path로부터 셰이더 코드를 얻고, instance로 Gpu를 생성한다. 창에서 Cmd + S로 저장할 때와 마찬가지로 생성된 Gpu를 통해 그림의 바이트 묶음을 얻어 save_png 함수로 출력한다.

기본값대로 출력한 이미지

단일 이미지 출력을 확인했다면 frame 입력으로 범위를 받게 해야 한다. 타입은 Rust 표준 라이브러리의 Range를 사용한다.

pub enum Command {
    Window {
        ...
    },
    Export {
        ...
        #[arg(long)]
        out: PathBuf,
        ...
        #[arg(long, default_value = "0..1", value_parser = parse_range_u32)]
        frame: Range<u32>,
        ...
    },
}

fn parse_range_u32(input: &str) -> anyhow::Result<Range<u32>> {
    match input.split_once("..") {
        Some((a_str, b_str)) => {
            let (a_u32, b_u32) = (
                a_str.parse::<u32>()?,
                b_str.parse::<u32>()?
            );
            if a_u32 >= b_u32 {
                return Err(anyhow!("입력 범위 역전"));
            }
            Ok(a_u32..b_u32)
        },
        None => {
            let frame = input.parse::<u32>()?;
            Ok(frame..frame + 1)
        },
    }
}

출력 위치 out을 입력받도록 한 뒤, frame으로 입력받는 &str을 Range로 파싱하는 함수를 만든다. 이를 value_parser로 사용해 Range를 반환하게 한다. 0..abc, 혹은 3..1, 1..1 등은 오류를 반환하게 하면 된다. 입력받은 문자열을 split_once를 이용해 “..”를 기준으로 나누고, parse로 u32 값으로 변환한 뒤 조건을 검사하면 된다. 숫자 하나만 입력해도 단일 프레임 출력이 가능하도록 “..” 없는 입력 처리도 해준다. default_value_t를 default_value로 변경해 기본값을 문자열로 하고 value_parser로 파싱 함수를 사용한다.

Command::Export { path, out, width, height, frame: frames, fps } => {
    ...
    let (output_path, output_stem) = match (out.parent(), out.file_stem()) {
        (Some(path), Some(stem)) => {
            (path, stem.to_string_lossy())
        },
        _ => {
            eprintln!("export: '저장경로/파일이름.확장자' 필요");
            std::process::exit(1)
        },
    };
    match std::fs::create_dir_all(output_path) {
        Ok(()) => (),
        Err(err) => {
            eprintln!("{err}: {output_path:?}");
            std::process::exit(1)
        },
    }

    for frame in frames {
        let time = frame as f32 / fps as f32;
        let bytes = match gpu.render_to_bytes(width, height, frame, time) {
            ...
        };

        let file_name = format!("{}_{:04}.png", output_stem, frame);
        let output_path = output_path.join(file_name);
        match save_png(&output_path, width, height, &bytes) {
            ...
        }
    }
},

입력받은 out의 폴더 경로 부분을 parent로 얻는다. create_dir_all에 얻은 경로를 입력해 경로상 폴더가 없다면 폴더를 생성한다. create_dir_all은 create_dir과 달리 상위 경로를 전부 생성하며, 폴더가 이미 존재해도 문제시하지 않는다. file_stem으로 out의 파일명을 얻어 출력에 사용한다. frame으로 입력받은 범위만큼 반복해 출력한다.

377프레임 GIF

현재 render_to_bytes 안에서 새 텍스처와 버퍼를 만들기에, 입력한 frame 범위만큼 텍스처와 버퍼가 만들어지고 버려지는 문제가 있다. 따라서 빈 텍스처와 뷰, 버퍼를 RenderTarget이라는 구조체로 묶어 render_to_bytes에 입력해 사용하도록 할 것이다.

pub struct RenderTarget {
    texture: wgpu::Texture,
    view: wgpu::TextureView,
    texture_buffer: wgpu::Buffer,
    width: u32,
    height: u32,
}
impl Gpu {
    ...

    pub fn create_render_target(&self, width: u32, height: u32) -> RenderTarget {
        let texture = self.device.create_texture(&wgpu::wgt::TextureDescriptor {
            label: Some("texture"),
            size: wgpu::Extent3d {
                width,
                height,
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::Rgba8UnormSrgb,
            usage: wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::RENDER_ATTACHMENT,
            view_formats: &[],
        });
        let view = texture.create_view(&wgpu::wgt::TextureViewDescriptor::default());

        let texture_buffer = self.device.create_buffer(&wgpu::wgt::BufferDescriptor {
            label: Some("texture_buffer"),
            size: (width_to_bytes(width) * height) as u64,
            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
            mapped_at_creation: false,
        });

        RenderTarget {
            texture,
            view,
            texture_buffer,
            width,
            height,
        }
    }

    pub fn render_to_bytes(
        &self,
        target: &RenderTarget,
        frame: u32,
        time: f32,
    ) -> anyhow::Result<Vec<u8>> {
        let texture = &target.texture;
        let view = &target.view;
        let (width, height) = (target.width, target.height);

        self.draw_to(&view, &self.export_pipeline, width, height, frame, time)?;

        let width_to_bytes = width_to_bytes(width);
        let texture_buffer = &target.texture_buffer;

        let mut command_encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
        command_encoder.copy_texture_to_buffer(
            texture.as_image_copy(),
            wgpu::TexelCopyBufferInfoBase {
                buffer: &texture_buffer,
                layout: wgpu::TexelCopyBufferLayout {
                    offset: 0,
                    bytes_per_row: Some(width_to_bytes),
                    rows_per_image: Some(height),
                },
            },
            wgpu::Extent3d {
                width,
                height,
                depth_or_array_layers: 1,
            },
        );
        let command_buffer = command_encoder.finish();
        let submission_index = self.queue.submit([command_buffer]);

        texture_buffer.map_async(
            wgpu::MapMode::Read,
            ..,
            |_| {},
        );
        self.device.poll(wgpu::PollType::Wait {
            submission_index: Some(submission_index),
            timeout: None,
        })?;

        let buffer_view = texture_buffer.get_mapped_range(..)?;
        let mut bytes = Vec::<u8>::new();

        for row in buffer_view.chunks(width_to_bytes as usize) {
            bytes.extend_from_slice(&row[..(width * 4) as usize]);
        }
        drop(buffer_view);
        texture_buffer.unmap();
        Ok(bytes)
    }
}

export 시에는 반복문 전에 create_render_target으로 RenderTarget을 한 번만 생성하고, 매 프레임 render_to_bytes에 입력해 재사용한다. 이제 export 명령으로 입력한 범위의 프레임을 PNG로 출력할 수 있다.

다음 글로 이어집니다.

I'm looking for an English tutor (⸝⸝◜▿◝⸝⸝ゝ)