main.rs - mozsearch

Enable keyboard shortcuts

use std::mem;

use std::path::PathBuf;

use std::fs::File;

use std::io::BufWriter;

use metal::{

    Buffer, Device, DeviceRef, LibraryRef, MTLClearColor, MTLLoadAction, MTLOrigin, MTLPixelFormat,

    MTLPrimitiveType, MTLRegion, MTLResourceOptions, MTLSize, MTLStoreAction, RenderPassDescriptor,

    RenderPassDescriptorRef, RenderPipelineDescriptor, RenderPipelineState, Texture,

    TextureDescriptor, TextureRef,

};

use png::ColorType;

const VIEW_WIDTH: u64 = 512;

const VIEW_HEIGHT: u64 = 512;

const TOTAL_BYTES: usize = (VIEW_WIDTH * VIEW_HEIGHT * 4) as usize;

const VERTEX_SHADER: &'static str = "triangle_vertex";

const FRAGMENT_SHADER: &'static str = "triangle_fragment";

// [2 bytes position, 3 bytes color] * 3

#[rustfmt::skip]

const VERTEX_ATTRIBS: [f32; 15] = [

    0.0, 0.5, 1.0, 0.0, 0.0,

    -0.5, -0.5, 0.0, 1.0, 0.0,

    0.5, -0.5, 0.0, 0.0, 1.0,

];

/// This example shows how to render headlessly by:

///

/// 1. Rendering a triangle to an MtlDrawable

///

/// 2. Waiting for the render to complete and the color texture to be synchronized with the CPU

///    by using a blit command encoder

///

/// 3. Reading the texture bytes from the MtlTexture

///

/// 4. Saving the texture to a PNG file

fn main() {

    let device = Device::system_default().expect("No device found");

    let texture = create_texture(&device);

    let library_path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))

        .join("examples/window/shaders.metallib");

    let library = device.new_library_with_file(library_path).unwrap();

    let pipeline_state = prepare_pipeline_state(&device, &library);

    let command_queue = device.new_command_queue();

    let vertex_buffer = create_vertex_buffer(&device);

    let render_pass_descriptor = RenderPassDescriptor::new();

    initialize_color_attachment(&render_pass_descriptor, &texture);

    let command_buffer = command_queue.new_command_buffer();

    let rc_encoder = command_buffer.new_render_command_encoder(&render_pass_descriptor);

    rc_encoder.set_render_pipeline_state(&pipeline_state);

    rc_encoder.set_vertex_buffer(0, Some(&vertex_buffer), 0);

    rc_encoder.draw_primitives(MTLPrimitiveType::Triangle, 0, 3);

    rc_encoder.end_encoding();

    render_pass_descriptor

        .color_attachments()

        .object_at(0)

        .unwrap()

        .set_load_action(MTLLoadAction::DontCare);

    let blit_encoder = command_buffer.new_blit_command_encoder();

    blit_encoder.synchronize_resource(&texture);

    blit_encoder.end_encoding();

    command_buffer.commit();

    command_buffer.wait_until_completed();

    save_image(&texture);

fn save_image(texture: &TextureRef) {

    let mut image = vec![0; TOTAL_BYTES];

    texture.get_bytes(

        image.as_mut_ptr() as *mut std::ffi::c_void,

        VIEW_WIDTH * 4,

        MTLRegion {

            origin: MTLOrigin { x: 0, y: 0, z: 0 },

            size: MTLSize {

                width: VIEW_WIDTH,

                height: VIEW_HEIGHT,

                depth: 1,

},

},

0,

);

    let out_file =

        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("examples/headless-render/out.png");

    let file = File::create(&out_file).unwrap();

    let ref mut w = BufWriter::new(file);

    let mut encoder = png::Encoder::new(w, VIEW_WIDTH as u32, VIEW_HEIGHT as u32);

    encoder.set_color(ColorType::Rgba);

    encoder.set_depth(png::BitDepth::Eight);

    let mut writer = encoder.write_header().unwrap();

    writer.write_image_data(&image).unwrap();

    println!("Image saved to {:?}", out_file);

fn create_texture(device: &Device) -> Texture {

    let texture = TextureDescriptor::new();

    texture.set_width(VIEW_WIDTH);

    texture.set_height(VIEW_HEIGHT);

    texture.set_pixel_format(MTLPixelFormat::RGBA8Unorm);

    device.new_texture(&texture)

fn prepare_pipeline_state(device: &DeviceRef, library: &LibraryRef) -> RenderPipelineState {

    let vert = library.get_function(VERTEX_SHADER, None).unwrap();

    let frag = library.get_function(FRAGMENT_SHADER, None).unwrap();

    let pipeline_state_descriptor = RenderPipelineDescriptor::new();

    pipeline_state_descriptor.set_vertex_function(Some(&vert));

    pipeline_state_descriptor.set_fragment_function(Some(&frag));

    pipeline_state_descriptor

        .color_attachments()

        .object_at(0)

        .unwrap()

        .set_pixel_format(MTLPixelFormat::RGBA8Unorm);

    device

        .new_render_pipeline_state(&pipeline_state_descriptor)

        .unwrap()

fn create_vertex_buffer(device: &DeviceRef) -> Buffer {

    device.new_buffer_with_data(

        VERTEX_ATTRIBS.as_ptr() as *const _,

        (VERTEX_ATTRIBS.len() * mem::size_of::<f32>()) as u64,

        MTLResourceOptions::CPUCacheModeDefaultCache | MTLResourceOptions::StorageModeManaged,

fn initialize_color_attachment(descriptor: &RenderPassDescriptorRef, texture: &TextureRef) {

    let color_attachment = descriptor.color_attachments().object_at(0).unwrap();

    color_attachment.set_texture(Some(texture));

    color_attachment.set_load_action(MTLLoadAction::Clear);

    color_attachment.set_clear_color(MTLClearColor::new(0.5, 0.2, 0.2, 1.0));

    color_attachment.set_store_action(MTLStoreAction::Store);