Struct BlitCommandEncoder 

pub struct BlitCommandEncoder { /* private fields */ }

Re-exports the Metal framework surface for this item. Apple’s id<MTLBlitCommandEncoder> — encodes buffer and texture copy work. Mirrors the Metal framework counterpart for this type.

Implementations

impl BlitCommandEncoder

pub const fn as_ptr(&self) -> *mut c_void

Mirrors the Metal framework constant fn.

impl BlitCommandEncoder

pub fn copy_buffer( &self, src: &MetalBuffer, src_offset: usize, dst: &MetalBuffer, dst_offset: usize, size: usize, ) -> bool

Copy size bytes from src into dst.

Examples found in repository

examples/05_render_and_explicit_encoders.rs (line 36)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    println!(
        "device: {} (registry id {})",
        device.name(),
        device.registry_id()
    );

    let queue = device.new_command_queue().expect("command queue");
    let status_buffer = queue
        .new_command_buffer_with_unretained_references()
        .expect("scratch command buffer");
    println!("scratch command buffer status={}", status_buffer.status());

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit_cb = queue.new_command_buffer().expect("blit command buffer");
    let blit = blit_cb
        .new_blit_command_encoder()
        .expect("blit command encoder");
    assert!(blit.fill_buffer(&src, 0..64, b'Z'));
    assert!(blit.copy_buffer(&src, 0, &dst, 0, 64));
    blit.end_encoding();
    blit_cb.commit();
    blit_cb.wait_until_completed();
    let copied = unsafe {
        core::slice::from_raw_parts(dst.contents().expect("dst contents").cast::<u8>(), 8)
    };
    println!("blit copied bytes: {copied:?}");

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[10, 20, 30, 40]);
    let compute_cb = queue.new_command_buffer().expect("compute command buffer");
    let compute = compute_cb
        .new_compute_command_encoder()
        .expect("compute command encoder");
    compute.set_compute_pipeline_state(&pipeline);
    compute.set_buffer(&buffer, 0, 0);
    compute.dispatch_threads((4, 1, 1), (1, 1, 1));
    compute.end_encoding();
    compute_cb.commit();
    compute_cb.wait_until_completed();
    println!("compute output: {:?}", common::read_u32_words(&buffer, 4));

    let render_library = device
        .new_library_with_source(common::RENDER_SRC)
        .expect("compile render library");
    let vertex = render_library
        .new_function("fullscreen_vertex")
        .expect("vertex function");
    let fragment = render_library
        .new_function("solid_fragment")
        .expect("fragment function");
    let render_pipeline = device
        .new_render_pipeline_state(&vertex, &fragment, pixel_format::BGRA8UNORM, 1)
        .expect("render pipeline");
    println!("render pipeline label: {:?}", render_pipeline.label());

    let render_target = device
        .new_texture(common::shared_render_target(4, 4))
        .expect("render target");
    let vertex_buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("vertex buffer");
    let render_cb = queue.new_command_buffer().expect("render command buffer");
    let render = render_cb
        .new_render_command_encoder(
            &render_target,
            load_action::CLEAR,
            store_action::STORE,
            [0.0, 0.0, 0.0, 1.0],
        )
        .expect("render command encoder");
    render.set_render_pipeline_state(&render_pipeline);
    render.set_vertex_buffer(&vertex_buffer, 0, 0);
    render.draw_primitives(primitive_type::TRIANGLE, 0, 3);
    render.end_encoding();
    render_cb.commit();
    render_cb.wait_until_completed();

    let mut rendered = vec![0_u8; 4 * 4 * 4];
    assert!(render_target.read_bytes_2d(&mut rendered, 16, (0, 0), (4, 4), 0));
    println!("first rendered pixel: {:?}", &rendered[..4]);

    let shared_texture = device
        .new_texture(TextureDescriptor::new_2d(4, 4, pixel_format::BGRA8UNORM))
        .expect("shared texture");
    let upload = vec![0x22_u8; 4 * 4 * 4];
    assert!(shared_texture.replace_region_2d(&upload, 16, (0, 0), (4, 4), 0));
    let mut download = vec![0_u8; upload.len()];
    assert!(shared_texture.read_bytes_2d(&mut download, 16, (0, 0), (4, 4), 0));
    let view = shared_texture
        .new_view(pixel_format::BGRA8UNORM)
        .expect("texture view");
    println!(
        "texture {}x{} usage={} storage_mode={} view_width={}",
        shared_texture.width(),
        shared_texture.height(),
        shared_texture.usage(),
        shared_texture.storage_mode(),
        view.width(),
    );
}

examples/07_advanced_objects.rs (line 79)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    let queue = device.new_command_queue().expect("command queue");
    let counter_sets = device.counter_set_names();
    println!("counter sets: {counter_sets:?}");

    if let Some(event) = device.new_shared_event() {
        event.set_signaled_value(1);
        println!("event signaled value={}", event.signaled_value());
        let signal = queue
            .new_command_buffer()
            .expect("event signal command buffer");
        signal.encode_signal_event(&event, 2);
        signal.commit();
        signal.wait_until_completed();
        println!(
            "event reached value 2: {}",
            event.wait_until_signaled_value(2, 1_000),
        );

        let wait = queue
            .new_command_buffer()
            .expect("event wait command buffer");
        wait.encode_wait_for_event(&event, 2);
        wait.commit();
        wait.wait_until_completed();
    }

    let fence_a = device.new_fence();
    let fence_b = device.new_fence();
    let sample_buffer = counter_sets.first().and_then(|name| {
        if device.supports_counter_sampling(counter_sampling_point::AT_BLIT_BOUNDARY) {
            device
                .new_counter_sample_buffer(name, 2, storage_mode::SHARED, Some("example-samples"))
                .ok()
        } else {
            None
        }
    });

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit = queue.new_command_buffer().expect("blit command buffer");
    let encoder = blit.new_blit_command_encoder().expect("blit encoder");
    let _ = encoder.fill_buffer(&src, 0..64, b'Q');
    if let Some(fence) = fence_a.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();

    let blit = queue
        .new_command_buffer()
        .expect("second blit command buffer");
    let encoder = blit
        .new_blit_command_encoder()
        .expect("second blit encoder");
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        let _ = encoder.sample_counters(sample_buffer, 0, false);
    }
    let _ = encoder.copy_buffer(&src, 0, &dst, 0, 64);
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        println!(
            "resolved counter bytes={}",
            sample_buffer
                .resolve_range(0..1)
                .map_or(0, |bytes| bytes.len())
        );
    }

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");
    let visible_table = pipeline.new_visible_function_table(1);
    let intersection_table = if device.supports_raytracing() {
        pipeline.new_intersection_function_table(1)
    } else {
        None
    };
    if let Some(table) = intersection_table.as_ref() {
        table.set_opaque_triangle_intersection_function(intersection_function_signature::NONE, 0);
    }
    let acceleration_structure = if device.supports_raytracing() {
        device.new_acceleration_structure_with_size(256)
    } else {
        None
    };

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[1, 2, 3, 4]);
    let texture = device
        .new_texture(apple_metal::TextureDescriptor::new_2d(
            4,
            4,
            apple_metal::pixel_format::BGRA8UNORM,
        ))
        .expect("compute texture");
    let compute = queue.new_command_buffer().expect("compute command buffer");
    let encoder = compute
        .new_compute_command_encoder()
        .expect("compute command encoder");
    encoder.set_compute_pipeline_state(&pipeline);
    encoder.set_buffer(&buffer, 0, 0);
    encoder.set_texture(&texture, 1);
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(table) = visible_table.as_ref() {
        encoder.set_visible_function_table(table, 2);
    }
    if let Some(table) = intersection_table.as_ref() {
        encoder.set_intersection_function_table(table, 3);
    }
    if let Some(acceleration_structure) = acceleration_structure.as_ref() {
        encoder.set_acceleration_structure(acceleration_structure, 4);
    }
    encoder.dispatch_threadgroups((1, 1, 1), (4, 1, 1));
    if let Some(fence) = fence_b.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    compute.commit();
    compute.wait_until_completed();
    println!(
        "compute buffer after dispatch: {:?}",
        common::read_u32_words(&buffer, 4)
    );

    if let Some(indirect) = device.new_indirect_command_buffer(
        indirect_command_type::CONCURRENT_DISPATCH,
        1,
        0,
        0,
        4,
        resource_options::STORAGE_MODE_PRIVATE,
    ) {
        indirect.reset_range(0..1);
        println!("indirect command buffer size={}", indirect.size());
    }

    if let Some(heap) = device.new_heap(1 << 20, storage_mode::SHARED) {
        if let Ok(residency_set) = device.new_residency_set(Some("example-residency"), 4) {
            let heap_buffer = heap
                .new_buffer(256, resource_options::STORAGE_MODE_SHARED)
                .expect("heap buffer");
            residency_set.add_buffer(&heap_buffer);
            residency_set.add_heap(&heap);
            residency_set.commit();
            residency_set.request_residency();
            queue.add_residency_set(&residency_set);
            queue.remove_residency_set(&residency_set);
            residency_set.end_residency();
            residency_set.remove_all_allocations();
            residency_set.commit();
            println!(
                "residency allocation count={}",
                residency_set.allocation_count()
            );
        } else {
            println!("residency sets unavailable on this OS");
        }
    }

    if let Some(capture_manager) = CaptureManager::shared() {
        println!(
            "capture supported for developer tools={} active={}",
            capture_manager.supports_destination(capture_destination::DEVELOPER_TOOLS),
            capture_manager.is_capturing(),
        );
        if let Some(scope) = capture_manager.new_capture_scope_with_device(&device) {
            scope.begin();
            scope.end();
        }
        if let Some(scope) = capture_manager.new_capture_scope_with_command_queue(&queue) {
            scope.begin();
            scope.end();
        }
    }
}

pub fn fill_buffer( &self, buffer: &MetalBuffer, range: Range<usize>, value: u8, ) -> bool

Fill a byte range of buffer with value.

Examples found in repository

examples/05_render_and_explicit_encoders.rs (line 35)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    println!(
        "device: {} (registry id {})",
        device.name(),
        device.registry_id()
    );

    let queue = device.new_command_queue().expect("command queue");
    let status_buffer = queue
        .new_command_buffer_with_unretained_references()
        .expect("scratch command buffer");
    println!("scratch command buffer status={}", status_buffer.status());

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit_cb = queue.new_command_buffer().expect("blit command buffer");
    let blit = blit_cb
        .new_blit_command_encoder()
        .expect("blit command encoder");
    assert!(blit.fill_buffer(&src, 0..64, b'Z'));
    assert!(blit.copy_buffer(&src, 0, &dst, 0, 64));
    blit.end_encoding();
    blit_cb.commit();
    blit_cb.wait_until_completed();
    let copied = unsafe {
        core::slice::from_raw_parts(dst.contents().expect("dst contents").cast::<u8>(), 8)
    };
    println!("blit copied bytes: {copied:?}");

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[10, 20, 30, 40]);
    let compute_cb = queue.new_command_buffer().expect("compute command buffer");
    let compute = compute_cb
        .new_compute_command_encoder()
        .expect("compute command encoder");
    compute.set_compute_pipeline_state(&pipeline);
    compute.set_buffer(&buffer, 0, 0);
    compute.dispatch_threads((4, 1, 1), (1, 1, 1));
    compute.end_encoding();
    compute_cb.commit();
    compute_cb.wait_until_completed();
    println!("compute output: {:?}", common::read_u32_words(&buffer, 4));

    let render_library = device
        .new_library_with_source(common::RENDER_SRC)
        .expect("compile render library");
    let vertex = render_library
        .new_function("fullscreen_vertex")
        .expect("vertex function");
    let fragment = render_library
        .new_function("solid_fragment")
        .expect("fragment function");
    let render_pipeline = device
        .new_render_pipeline_state(&vertex, &fragment, pixel_format::BGRA8UNORM, 1)
        .expect("render pipeline");
    println!("render pipeline label: {:?}", render_pipeline.label());

    let render_target = device
        .new_texture(common::shared_render_target(4, 4))
        .expect("render target");
    let vertex_buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("vertex buffer");
    let render_cb = queue.new_command_buffer().expect("render command buffer");
    let render = render_cb
        .new_render_command_encoder(
            &render_target,
            load_action::CLEAR,
            store_action::STORE,
            [0.0, 0.0, 0.0, 1.0],
        )
        .expect("render command encoder");
    render.set_render_pipeline_state(&render_pipeline);
    render.set_vertex_buffer(&vertex_buffer, 0, 0);
    render.draw_primitives(primitive_type::TRIANGLE, 0, 3);
    render.end_encoding();
    render_cb.commit();
    render_cb.wait_until_completed();

    let mut rendered = vec![0_u8; 4 * 4 * 4];
    assert!(render_target.read_bytes_2d(&mut rendered, 16, (0, 0), (4, 4), 0));
    println!("first rendered pixel: {:?}", &rendered[..4]);

    let shared_texture = device
        .new_texture(TextureDescriptor::new_2d(4, 4, pixel_format::BGRA8UNORM))
        .expect("shared texture");
    let upload = vec![0x22_u8; 4 * 4 * 4];
    assert!(shared_texture.replace_region_2d(&upload, 16, (0, 0), (4, 4), 0));
    let mut download = vec![0_u8; upload.len()];
    assert!(shared_texture.read_bytes_2d(&mut download, 16, (0, 0), (4, 4), 0));
    let view = shared_texture
        .new_view(pixel_format::BGRA8UNORM)
        .expect("texture view");
    println!(
        "texture {}x{} usage={} storage_mode={} view_width={}",
        shared_texture.width(),
        shared_texture.height(),
        shared_texture.usage(),
        shared_texture.storage_mode(),
        view.width(),
    );
}

examples/07_advanced_objects.rs (line 59)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    let queue = device.new_command_queue().expect("command queue");
    let counter_sets = device.counter_set_names();
    println!("counter sets: {counter_sets:?}");

    if let Some(event) = device.new_shared_event() {
        event.set_signaled_value(1);
        println!("event signaled value={}", event.signaled_value());
        let signal = queue
            .new_command_buffer()
            .expect("event signal command buffer");
        signal.encode_signal_event(&event, 2);
        signal.commit();
        signal.wait_until_completed();
        println!(
            "event reached value 2: {}",
            event.wait_until_signaled_value(2, 1_000),
        );

        let wait = queue
            .new_command_buffer()
            .expect("event wait command buffer");
        wait.encode_wait_for_event(&event, 2);
        wait.commit();
        wait.wait_until_completed();
    }

    let fence_a = device.new_fence();
    let fence_b = device.new_fence();
    let sample_buffer = counter_sets.first().and_then(|name| {
        if device.supports_counter_sampling(counter_sampling_point::AT_BLIT_BOUNDARY) {
            device
                .new_counter_sample_buffer(name, 2, storage_mode::SHARED, Some("example-samples"))
                .ok()
        } else {
            None
        }
    });

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit = queue.new_command_buffer().expect("blit command buffer");
    let encoder = blit.new_blit_command_encoder().expect("blit encoder");
    let _ = encoder.fill_buffer(&src, 0..64, b'Q');
    if let Some(fence) = fence_a.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();

    let blit = queue
        .new_command_buffer()
        .expect("second blit command buffer");
    let encoder = blit
        .new_blit_command_encoder()
        .expect("second blit encoder");
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        let _ = encoder.sample_counters(sample_buffer, 0, false);
    }
    let _ = encoder.copy_buffer(&src, 0, &dst, 0, 64);
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        println!(
            "resolved counter bytes={}",
            sample_buffer
                .resolve_range(0..1)
                .map_or(0, |bytes| bytes.len())
        );
    }

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");
    let visible_table = pipeline.new_visible_function_table(1);
    let intersection_table = if device.supports_raytracing() {
        pipeline.new_intersection_function_table(1)
    } else {
        None
    };
    if let Some(table) = intersection_table.as_ref() {
        table.set_opaque_triangle_intersection_function(intersection_function_signature::NONE, 0);
    }
    let acceleration_structure = if device.supports_raytracing() {
        device.new_acceleration_structure_with_size(256)
    } else {
        None
    };

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[1, 2, 3, 4]);
    let texture = device
        .new_texture(apple_metal::TextureDescriptor::new_2d(
            4,
            4,
            apple_metal::pixel_format::BGRA8UNORM,
        ))
        .expect("compute texture");
    let compute = queue.new_command_buffer().expect("compute command buffer");
    let encoder = compute
        .new_compute_command_encoder()
        .expect("compute command encoder");
    encoder.set_compute_pipeline_state(&pipeline);
    encoder.set_buffer(&buffer, 0, 0);
    encoder.set_texture(&texture, 1);
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(table) = visible_table.as_ref() {
        encoder.set_visible_function_table(table, 2);
    }
    if let Some(table) = intersection_table.as_ref() {
        encoder.set_intersection_function_table(table, 3);
    }
    if let Some(acceleration_structure) = acceleration_structure.as_ref() {
        encoder.set_acceleration_structure(acceleration_structure, 4);
    }
    encoder.dispatch_threadgroups((1, 1, 1), (4, 1, 1));
    if let Some(fence) = fence_b.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    compute.commit();
    compute.wait_until_completed();
    println!(
        "compute buffer after dispatch: {:?}",
        common::read_u32_words(&buffer, 4)
    );

    if let Some(indirect) = device.new_indirect_command_buffer(
        indirect_command_type::CONCURRENT_DISPATCH,
        1,
        0,
        0,
        4,
        resource_options::STORAGE_MODE_PRIVATE,
    ) {
        indirect.reset_range(0..1);
        println!("indirect command buffer size={}", indirect.size());
    }

    if let Some(heap) = device.new_heap(1 << 20, storage_mode::SHARED) {
        if let Ok(residency_set) = device.new_residency_set(Some("example-residency"), 4) {
            let heap_buffer = heap
                .new_buffer(256, resource_options::STORAGE_MODE_SHARED)
                .expect("heap buffer");
            residency_set.add_buffer(&heap_buffer);
            residency_set.add_heap(&heap);
            residency_set.commit();
            residency_set.request_residency();
            queue.add_residency_set(&residency_set);
            queue.remove_residency_set(&residency_set);
            residency_set.end_residency();
            residency_set.remove_all_allocations();
            residency_set.commit();
            println!(
                "residency allocation count={}",
                residency_set.allocation_count()
            );
        } else {
            println!("residency sets unavailable on this OS");
        }
    }

    if let Some(capture_manager) = CaptureManager::shared() {
        println!(
            "capture supported for developer tools={} active={}",
            capture_manager.supports_destination(capture_destination::DEVELOPER_TOOLS),
            capture_manager.is_capturing(),
        );
        if let Some(scope) = capture_manager.new_capture_scope_with_device(&device) {
            scope.begin();
            scope.end();
        }
        if let Some(scope) = capture_manager.new_capture_scope_with_command_queue(&queue) {
            scope.begin();
            scope.end();
        }
    }
}

pub fn sample_counters( &self, sample_buffer: &CounterSampleBuffer, sample_index: usize, barrier: bool, ) -> bool

Sample hardware counters into sample_buffer.

Examples found in repository

examples/07_advanced_objects.rs (line 77)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    let queue = device.new_command_queue().expect("command queue");
    let counter_sets = device.counter_set_names();
    println!("counter sets: {counter_sets:?}");

    if let Some(event) = device.new_shared_event() {
        event.set_signaled_value(1);
        println!("event signaled value={}", event.signaled_value());
        let signal = queue
            .new_command_buffer()
            .expect("event signal command buffer");
        signal.encode_signal_event(&event, 2);
        signal.commit();
        signal.wait_until_completed();
        println!(
            "event reached value 2: {}",
            event.wait_until_signaled_value(2, 1_000),
        );

        let wait = queue
            .new_command_buffer()
            .expect("event wait command buffer");
        wait.encode_wait_for_event(&event, 2);
        wait.commit();
        wait.wait_until_completed();
    }

    let fence_a = device.new_fence();
    let fence_b = device.new_fence();
    let sample_buffer = counter_sets.first().and_then(|name| {
        if device.supports_counter_sampling(counter_sampling_point::AT_BLIT_BOUNDARY) {
            device
                .new_counter_sample_buffer(name, 2, storage_mode::SHARED, Some("example-samples"))
                .ok()
        } else {
            None
        }
    });

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit = queue.new_command_buffer().expect("blit command buffer");
    let encoder = blit.new_blit_command_encoder().expect("blit encoder");
    let _ = encoder.fill_buffer(&src, 0..64, b'Q');
    if let Some(fence) = fence_a.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();

    let blit = queue
        .new_command_buffer()
        .expect("second blit command buffer");
    let encoder = blit
        .new_blit_command_encoder()
        .expect("second blit encoder");
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        let _ = encoder.sample_counters(sample_buffer, 0, false);
    }
    let _ = encoder.copy_buffer(&src, 0, &dst, 0, 64);
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        println!(
            "resolved counter bytes={}",
            sample_buffer
                .resolve_range(0..1)
                .map_or(0, |bytes| bytes.len())
        );
    }

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");
    let visible_table = pipeline.new_visible_function_table(1);
    let intersection_table = if device.supports_raytracing() {
        pipeline.new_intersection_function_table(1)
    } else {
        None
    };
    if let Some(table) = intersection_table.as_ref() {
        table.set_opaque_triangle_intersection_function(intersection_function_signature::NONE, 0);
    }
    let acceleration_structure = if device.supports_raytracing() {
        device.new_acceleration_structure_with_size(256)
    } else {
        None
    };

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[1, 2, 3, 4]);
    let texture = device
        .new_texture(apple_metal::TextureDescriptor::new_2d(
            4,
            4,
            apple_metal::pixel_format::BGRA8UNORM,
        ))
        .expect("compute texture");
    let compute = queue.new_command_buffer().expect("compute command buffer");
    let encoder = compute
        .new_compute_command_encoder()
        .expect("compute command encoder");
    encoder.set_compute_pipeline_state(&pipeline);
    encoder.set_buffer(&buffer, 0, 0);
    encoder.set_texture(&texture, 1);
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(table) = visible_table.as_ref() {
        encoder.set_visible_function_table(table, 2);
    }
    if let Some(table) = intersection_table.as_ref() {
        encoder.set_intersection_function_table(table, 3);
    }
    if let Some(acceleration_structure) = acceleration_structure.as_ref() {
        encoder.set_acceleration_structure(acceleration_structure, 4);
    }
    encoder.dispatch_threadgroups((1, 1, 1), (4, 1, 1));
    if let Some(fence) = fence_b.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    compute.commit();
    compute.wait_until_completed();
    println!(
        "compute buffer after dispatch: {:?}",
        common::read_u32_words(&buffer, 4)
    );

    if let Some(indirect) = device.new_indirect_command_buffer(
        indirect_command_type::CONCURRENT_DISPATCH,
        1,
        0,
        0,
        4,
        resource_options::STORAGE_MODE_PRIVATE,
    ) {
        indirect.reset_range(0..1);
        println!("indirect command buffer size={}", indirect.size());
    }

    if let Some(heap) = device.new_heap(1 << 20, storage_mode::SHARED) {
        if let Ok(residency_set) = device.new_residency_set(Some("example-residency"), 4) {
            let heap_buffer = heap
                .new_buffer(256, resource_options::STORAGE_MODE_SHARED)
                .expect("heap buffer");
            residency_set.add_buffer(&heap_buffer);
            residency_set.add_heap(&heap);
            residency_set.commit();
            residency_set.request_residency();
            queue.add_residency_set(&residency_set);
            queue.remove_residency_set(&residency_set);
            residency_set.end_residency();
            residency_set.remove_all_allocations();
            residency_set.commit();
            println!(
                "residency allocation count={}",
                residency_set.allocation_count()
            );
        } else {
            println!("residency sets unavailable on this OS");
        }
    }

    if let Some(capture_manager) = CaptureManager::shared() {
        println!(
            "capture supported for developer tools={} active={}",
            capture_manager.supports_destination(capture_destination::DEVELOPER_TOOLS),
            capture_manager.is_capturing(),
        );
        if let Some(scope) = capture_manager.new_capture_scope_with_device(&device) {
            scope.begin();
            scope.end();
        }
        if let Some(scope) = capture_manager.new_capture_scope_with_command_queue(&queue) {
            scope.begin();
            scope.end();
        }
    }
}

pub fn update_fence(&self, fence: &Fence)

Update fence with work encoded so far.

Examples found in repository

examples/07_advanced_objects.rs (line 61)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    let queue = device.new_command_queue().expect("command queue");
    let counter_sets = device.counter_set_names();
    println!("counter sets: {counter_sets:?}");

    if let Some(event) = device.new_shared_event() {
        event.set_signaled_value(1);
        println!("event signaled value={}", event.signaled_value());
        let signal = queue
            .new_command_buffer()
            .expect("event signal command buffer");
        signal.encode_signal_event(&event, 2);
        signal.commit();
        signal.wait_until_completed();
        println!(
            "event reached value 2: {}",
            event.wait_until_signaled_value(2, 1_000),
        );

        let wait = queue
            .new_command_buffer()
            .expect("event wait command buffer");
        wait.encode_wait_for_event(&event, 2);
        wait.commit();
        wait.wait_until_completed();
    }

    let fence_a = device.new_fence();
    let fence_b = device.new_fence();
    let sample_buffer = counter_sets.first().and_then(|name| {
        if device.supports_counter_sampling(counter_sampling_point::AT_BLIT_BOUNDARY) {
            device
                .new_counter_sample_buffer(name, 2, storage_mode::SHARED, Some("example-samples"))
                .ok()
        } else {
            None
        }
    });

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit = queue.new_command_buffer().expect("blit command buffer");
    let encoder = blit.new_blit_command_encoder().expect("blit encoder");
    let _ = encoder.fill_buffer(&src, 0..64, b'Q');
    if let Some(fence) = fence_a.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();

    let blit = queue
        .new_command_buffer()
        .expect("second blit command buffer");
    let encoder = blit
        .new_blit_command_encoder()
        .expect("second blit encoder");
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        let _ = encoder.sample_counters(sample_buffer, 0, false);
    }
    let _ = encoder.copy_buffer(&src, 0, &dst, 0, 64);
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        println!(
            "resolved counter bytes={}",
            sample_buffer
                .resolve_range(0..1)
                .map_or(0, |bytes| bytes.len())
        );
    }

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");
    let visible_table = pipeline.new_visible_function_table(1);
    let intersection_table = if device.supports_raytracing() {
        pipeline.new_intersection_function_table(1)
    } else {
        None
    };
    if let Some(table) = intersection_table.as_ref() {
        table.set_opaque_triangle_intersection_function(intersection_function_signature::NONE, 0);
    }
    let acceleration_structure = if device.supports_raytracing() {
        device.new_acceleration_structure_with_size(256)
    } else {
        None
    };

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[1, 2, 3, 4]);
    let texture = device
        .new_texture(apple_metal::TextureDescriptor::new_2d(
            4,
            4,
            apple_metal::pixel_format::BGRA8UNORM,
        ))
        .expect("compute texture");
    let compute = queue.new_command_buffer().expect("compute command buffer");
    let encoder = compute
        .new_compute_command_encoder()
        .expect("compute command encoder");
    encoder.set_compute_pipeline_state(&pipeline);
    encoder.set_buffer(&buffer, 0, 0);
    encoder.set_texture(&texture, 1);
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(table) = visible_table.as_ref() {
        encoder.set_visible_function_table(table, 2);
    }
    if let Some(table) = intersection_table.as_ref() {
        encoder.set_intersection_function_table(table, 3);
    }
    if let Some(acceleration_structure) = acceleration_structure.as_ref() {
        encoder.set_acceleration_structure(acceleration_structure, 4);
    }
    encoder.dispatch_threadgroups((1, 1, 1), (4, 1, 1));
    if let Some(fence) = fence_b.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    compute.commit();
    compute.wait_until_completed();
    println!(
        "compute buffer after dispatch: {:?}",
        common::read_u32_words(&buffer, 4)
    );

    if let Some(indirect) = device.new_indirect_command_buffer(
        indirect_command_type::CONCURRENT_DISPATCH,
        1,
        0,
        0,
        4,
        resource_options::STORAGE_MODE_PRIVATE,
    ) {
        indirect.reset_range(0..1);
        println!("indirect command buffer size={}", indirect.size());
    }

    if let Some(heap) = device.new_heap(1 << 20, storage_mode::SHARED) {
        if let Ok(residency_set) = device.new_residency_set(Some("example-residency"), 4) {
            let heap_buffer = heap
                .new_buffer(256, resource_options::STORAGE_MODE_SHARED)
                .expect("heap buffer");
            residency_set.add_buffer(&heap_buffer);
            residency_set.add_heap(&heap);
            residency_set.commit();
            residency_set.request_residency();
            queue.add_residency_set(&residency_set);
            queue.remove_residency_set(&residency_set);
            residency_set.end_residency();
            residency_set.remove_all_allocations();
            residency_set.commit();
            println!(
                "residency allocation count={}",
                residency_set.allocation_count()
            );
        } else {
            println!("residency sets unavailable on this OS");
        }
    }

    if let Some(capture_manager) = CaptureManager::shared() {
        println!(
            "capture supported for developer tools={} active={}",
            capture_manager.supports_destination(capture_destination::DEVELOPER_TOOLS),
            capture_manager.is_capturing(),
        );
        if let Some(scope) = capture_manager.new_capture_scope_with_device(&device) {
            scope.begin();
            scope.end();
        }
        if let Some(scope) = capture_manager.new_capture_scope_with_command_queue(&queue) {
            scope.begin();
            scope.end();
        }
    }
}

pub fn wait_for_fence(&self, fence: &Fence)

Wait for fence before executing subsequent work.

Examples found in repository

examples/07_advanced_objects.rs (line 74)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    let queue = device.new_command_queue().expect("command queue");
    let counter_sets = device.counter_set_names();
    println!("counter sets: {counter_sets:?}");

    if let Some(event) = device.new_shared_event() {
        event.set_signaled_value(1);
        println!("event signaled value={}", event.signaled_value());
        let signal = queue
            .new_command_buffer()
            .expect("event signal command buffer");
        signal.encode_signal_event(&event, 2);
        signal.commit();
        signal.wait_until_completed();
        println!(
            "event reached value 2: {}",
            event.wait_until_signaled_value(2, 1_000),
        );

        let wait = queue
            .new_command_buffer()
            .expect("event wait command buffer");
        wait.encode_wait_for_event(&event, 2);
        wait.commit();
        wait.wait_until_completed();
    }

    let fence_a = device.new_fence();
    let fence_b = device.new_fence();
    let sample_buffer = counter_sets.first().and_then(|name| {
        if device.supports_counter_sampling(counter_sampling_point::AT_BLIT_BOUNDARY) {
            device
                .new_counter_sample_buffer(name, 2, storage_mode::SHARED, Some("example-samples"))
                .ok()
        } else {
            None
        }
    });

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit = queue.new_command_buffer().expect("blit command buffer");
    let encoder = blit.new_blit_command_encoder().expect("blit encoder");
    let _ = encoder.fill_buffer(&src, 0..64, b'Q');
    if let Some(fence) = fence_a.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();

    let blit = queue
        .new_command_buffer()
        .expect("second blit command buffer");
    let encoder = blit
        .new_blit_command_encoder()
        .expect("second blit encoder");
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        let _ = encoder.sample_counters(sample_buffer, 0, false);
    }
    let _ = encoder.copy_buffer(&src, 0, &dst, 0, 64);
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        println!(
            "resolved counter bytes={}",
            sample_buffer
                .resolve_range(0..1)
                .map_or(0, |bytes| bytes.len())
        );
    }

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");
    let visible_table = pipeline.new_visible_function_table(1);
    let intersection_table = if device.supports_raytracing() {
        pipeline.new_intersection_function_table(1)
    } else {
        None
    };
    if let Some(table) = intersection_table.as_ref() {
        table.set_opaque_triangle_intersection_function(intersection_function_signature::NONE, 0);
    }
    let acceleration_structure = if device.supports_raytracing() {
        device.new_acceleration_structure_with_size(256)
    } else {
        None
    };

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[1, 2, 3, 4]);
    let texture = device
        .new_texture(apple_metal::TextureDescriptor::new_2d(
            4,
            4,
            apple_metal::pixel_format::BGRA8UNORM,
        ))
        .expect("compute texture");
    let compute = queue.new_command_buffer().expect("compute command buffer");
    let encoder = compute
        .new_compute_command_encoder()
        .expect("compute command encoder");
    encoder.set_compute_pipeline_state(&pipeline);
    encoder.set_buffer(&buffer, 0, 0);
    encoder.set_texture(&texture, 1);
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(table) = visible_table.as_ref() {
        encoder.set_visible_function_table(table, 2);
    }
    if let Some(table) = intersection_table.as_ref() {
        encoder.set_intersection_function_table(table, 3);
    }
    if let Some(acceleration_structure) = acceleration_structure.as_ref() {
        encoder.set_acceleration_structure(acceleration_structure, 4);
    }
    encoder.dispatch_threadgroups((1, 1, 1), (4, 1, 1));
    if let Some(fence) = fence_b.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    compute.commit();
    compute.wait_until_completed();
    println!(
        "compute buffer after dispatch: {:?}",
        common::read_u32_words(&buffer, 4)
    );

    if let Some(indirect) = device.new_indirect_command_buffer(
        indirect_command_type::CONCURRENT_DISPATCH,
        1,
        0,
        0,
        4,
        resource_options::STORAGE_MODE_PRIVATE,
    ) {
        indirect.reset_range(0..1);
        println!("indirect command buffer size={}", indirect.size());
    }

    if let Some(heap) = device.new_heap(1 << 20, storage_mode::SHARED) {
        if let Ok(residency_set) = device.new_residency_set(Some("example-residency"), 4) {
            let heap_buffer = heap
                .new_buffer(256, resource_options::STORAGE_MODE_SHARED)
                .expect("heap buffer");
            residency_set.add_buffer(&heap_buffer);
            residency_set.add_heap(&heap);
            residency_set.commit();
            residency_set.request_residency();
            queue.add_residency_set(&residency_set);
            queue.remove_residency_set(&residency_set);
            residency_set.end_residency();
            residency_set.remove_all_allocations();
            residency_set.commit();
            println!(
                "residency allocation count={}",
                residency_set.allocation_count()
            );
        } else {
            println!("residency sets unavailable on this OS");
        }
    }

    if let Some(capture_manager) = CaptureManager::shared() {
        println!(
            "capture supported for developer tools={} active={}",
            capture_manager.supports_destination(capture_destination::DEVELOPER_TOOLS),
            capture_manager.is_capturing(),
        );
        if let Some(scope) = capture_manager.new_capture_scope_with_device(&device) {
            scope.begin();
            scope.end();
        }
        if let Some(scope) = capture_manager.new_capture_scope_with_command_queue(&queue) {
            scope.begin();
            scope.end();
        }
    }
}

pub fn end_encoding(&self)

Finish encoding commands.

Examples found in repository

examples/05_render_and_explicit_encoders.rs (line 37)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    println!(
        "device: {} (registry id {})",
        device.name(),
        device.registry_id()
    );

    let queue = device.new_command_queue().expect("command queue");
    let status_buffer = queue
        .new_command_buffer_with_unretained_references()
        .expect("scratch command buffer");
    println!("scratch command buffer status={}", status_buffer.status());

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit_cb = queue.new_command_buffer().expect("blit command buffer");
    let blit = blit_cb
        .new_blit_command_encoder()
        .expect("blit command encoder");
    assert!(blit.fill_buffer(&src, 0..64, b'Z'));
    assert!(blit.copy_buffer(&src, 0, &dst, 0, 64));
    blit.end_encoding();
    blit_cb.commit();
    blit_cb.wait_until_completed();
    let copied = unsafe {
        core::slice::from_raw_parts(dst.contents().expect("dst contents").cast::<u8>(), 8)
    };
    println!("blit copied bytes: {copied:?}");

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[10, 20, 30, 40]);
    let compute_cb = queue.new_command_buffer().expect("compute command buffer");
    let compute = compute_cb
        .new_compute_command_encoder()
        .expect("compute command encoder");
    compute.set_compute_pipeline_state(&pipeline);
    compute.set_buffer(&buffer, 0, 0);
    compute.dispatch_threads((4, 1, 1), (1, 1, 1));
    compute.end_encoding();
    compute_cb.commit();
    compute_cb.wait_until_completed();
    println!("compute output: {:?}", common::read_u32_words(&buffer, 4));

    let render_library = device
        .new_library_with_source(common::RENDER_SRC)
        .expect("compile render library");
    let vertex = render_library
        .new_function("fullscreen_vertex")
        .expect("vertex function");
    let fragment = render_library
        .new_function("solid_fragment")
        .expect("fragment function");
    let render_pipeline = device
        .new_render_pipeline_state(&vertex, &fragment, pixel_format::BGRA8UNORM, 1)
        .expect("render pipeline");
    println!("render pipeline label: {:?}", render_pipeline.label());

    let render_target = device
        .new_texture(common::shared_render_target(4, 4))
        .expect("render target");
    let vertex_buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("vertex buffer");
    let render_cb = queue.new_command_buffer().expect("render command buffer");
    let render = render_cb
        .new_render_command_encoder(
            &render_target,
            load_action::CLEAR,
            store_action::STORE,
            [0.0, 0.0, 0.0, 1.0],
        )
        .expect("render command encoder");
    render.set_render_pipeline_state(&render_pipeline);
    render.set_vertex_buffer(&vertex_buffer, 0, 0);
    render.draw_primitives(primitive_type::TRIANGLE, 0, 3);
    render.end_encoding();
    render_cb.commit();
    render_cb.wait_until_completed();

    let mut rendered = vec![0_u8; 4 * 4 * 4];
    assert!(render_target.read_bytes_2d(&mut rendered, 16, (0, 0), (4, 4), 0));
    println!("first rendered pixel: {:?}", &rendered[..4]);

    let shared_texture = device
        .new_texture(TextureDescriptor::new_2d(4, 4, pixel_format::BGRA8UNORM))
        .expect("shared texture");
    let upload = vec![0x22_u8; 4 * 4 * 4];
    assert!(shared_texture.replace_region_2d(&upload, 16, (0, 0), (4, 4), 0));
    let mut download = vec![0_u8; upload.len()];
    assert!(shared_texture.read_bytes_2d(&mut download, 16, (0, 0), (4, 4), 0));
    let view = shared_texture
        .new_view(pixel_format::BGRA8UNORM)
        .expect("texture view");
    println!(
        "texture {}x{} usage={} storage_mode={} view_width={}",
        shared_texture.width(),
        shared_texture.height(),
        shared_texture.usage(),
        shared_texture.storage_mode(),
        view.width(),
    );
}

examples/07_advanced_objects.rs (line 63)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    let queue = device.new_command_queue().expect("command queue");
    let counter_sets = device.counter_set_names();
    println!("counter sets: {counter_sets:?}");

    if let Some(event) = device.new_shared_event() {
        event.set_signaled_value(1);
        println!("event signaled value={}", event.signaled_value());
        let signal = queue
            .new_command_buffer()
            .expect("event signal command buffer");
        signal.encode_signal_event(&event, 2);
        signal.commit();
        signal.wait_until_completed();
        println!(
            "event reached value 2: {}",
            event.wait_until_signaled_value(2, 1_000),
        );

        let wait = queue
            .new_command_buffer()
            .expect("event wait command buffer");
        wait.encode_wait_for_event(&event, 2);
        wait.commit();
        wait.wait_until_completed();
    }

    let fence_a = device.new_fence();
    let fence_b = device.new_fence();
    let sample_buffer = counter_sets.first().and_then(|name| {
        if device.supports_counter_sampling(counter_sampling_point::AT_BLIT_BOUNDARY) {
            device
                .new_counter_sample_buffer(name, 2, storage_mode::SHARED, Some("example-samples"))
                .ok()
        } else {
            None
        }
    });

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit = queue.new_command_buffer().expect("blit command buffer");
    let encoder = blit.new_blit_command_encoder().expect("blit encoder");
    let _ = encoder.fill_buffer(&src, 0..64, b'Q');
    if let Some(fence) = fence_a.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();

    let blit = queue
        .new_command_buffer()
        .expect("second blit command buffer");
    let encoder = blit
        .new_blit_command_encoder()
        .expect("second blit encoder");
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        let _ = encoder.sample_counters(sample_buffer, 0, false);
    }
    let _ = encoder.copy_buffer(&src, 0, &dst, 0, 64);
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        println!(
            "resolved counter bytes={}",
            sample_buffer
                .resolve_range(0..1)
                .map_or(0, |bytes| bytes.len())
        );
    }

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");
    let visible_table = pipeline.new_visible_function_table(1);
    let intersection_table = if device.supports_raytracing() {
        pipeline.new_intersection_function_table(1)
    } else {
        None
    };
    if let Some(table) = intersection_table.as_ref() {
        table.set_opaque_triangle_intersection_function(intersection_function_signature::NONE, 0);
    }
    let acceleration_structure = if device.supports_raytracing() {
        device.new_acceleration_structure_with_size(256)
    } else {
        None
    };

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[1, 2, 3, 4]);
    let texture = device
        .new_texture(apple_metal::TextureDescriptor::new_2d(
            4,
            4,
            apple_metal::pixel_format::BGRA8UNORM,
        ))
        .expect("compute texture");
    let compute = queue.new_command_buffer().expect("compute command buffer");
    let encoder = compute
        .new_compute_command_encoder()
        .expect("compute command encoder");
    encoder.set_compute_pipeline_state(&pipeline);
    encoder.set_buffer(&buffer, 0, 0);
    encoder.set_texture(&texture, 1);
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(table) = visible_table.as_ref() {
        encoder.set_visible_function_table(table, 2);
    }
    if let Some(table) = intersection_table.as_ref() {
        encoder.set_intersection_function_table(table, 3);
    }
    if let Some(acceleration_structure) = acceleration_structure.as_ref() {
        encoder.set_acceleration_structure(acceleration_structure, 4);
    }
    encoder.dispatch_threadgroups((1, 1, 1), (4, 1, 1));
    if let Some(fence) = fence_b.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    compute.commit();
    compute.wait_until_completed();
    println!(
        "compute buffer after dispatch: {:?}",
        common::read_u32_words(&buffer, 4)
    );

    if let Some(indirect) = device.new_indirect_command_buffer(
        indirect_command_type::CONCURRENT_DISPATCH,
        1,
        0,
        0,
        4,
        resource_options::STORAGE_MODE_PRIVATE,
    ) {
        indirect.reset_range(0..1);
        println!("indirect command buffer size={}", indirect.size());
    }

    if let Some(heap) = device.new_heap(1 << 20, storage_mode::SHARED) {
        if let Ok(residency_set) = device.new_residency_set(Some("example-residency"), 4) {
            let heap_buffer = heap
                .new_buffer(256, resource_options::STORAGE_MODE_SHARED)
                .expect("heap buffer");
            residency_set.add_buffer(&heap_buffer);
            residency_set.add_heap(&heap);
            residency_set.commit();
            residency_set.request_residency();
            queue.add_residency_set(&residency_set);
            queue.remove_residency_set(&residency_set);
            residency_set.end_residency();
            residency_set.remove_all_allocations();
            residency_set.commit();
            println!(
                "residency allocation count={}",
                residency_set.allocation_count()
            );
        } else {
            println!("residency sets unavailable on this OS");
        }
    }

    if let Some(capture_manager) = CaptureManager::shared() {
        println!(
            "capture supported for developer tools={} active={}",
            capture_manager.supports_destination(capture_destination::DEVELOPER_TOOLS),
            capture_manager.is_capturing(),
        );
        if let Some(scope) = capture_manager.new_capture_scope_with_device(&device) {
            scope.begin();
            scope.end();
        }
        if let Some(scope) = capture_manager.new_capture_scope_with_command_queue(&queue) {
            scope.begin();
            scope.end();
        }
    }
}

Trait Implementations

impl Drop for BlitCommandEncoder

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.