Trait MTL4CommandQueue 

pub unsafe trait MTL4CommandQueue:
    NSObjectProtocol
    + Send
    + Sync {
    // Provided methods
    fn device(&self) -> Retained<ProtocolObject<dyn MTLDevice>>
       where Self: Sized + Message { ... }
    fn label(&self) -> Option<Retained<NSString>>
       where Self: Sized + Message { ... }
    unsafe fn commit_count(
        &self,
        command_buffers: NonNull<NonNull<ProtocolObject<dyn MTL4CommandBuffer>>>,
        count: NSUInteger,
    )
       where Self: Sized + Message { ... }
    unsafe fn commit_count_options(
        &self,
        command_buffers: NonNull<NonNull<ProtocolObject<dyn MTL4CommandBuffer>>>,
        count: NSUInteger,
        options: &MTL4CommitOptions,
    )
       where Self: Sized + Message { ... }
    fn signalEvent_value(
        &self,
        event: &ProtocolObject<dyn MTLEvent>,
        value: u64,
    )
       where Self: Sized + Message { ... }
    fn waitForEvent_value(
        &self,
        event: &ProtocolObject<dyn MTLEvent>,
        value: u64,
    )
       where Self: Sized + Message { ... }
    fn signalDrawable(&self, drawable: &ProtocolObject<dyn MTLDrawable>)
       where Self: Sized + Message { ... }
    fn waitForDrawable(&self, drawable: &ProtocolObject<dyn MTLDrawable>)
       where Self: Sized + Message { ... }
    fn addResidencySet(
        &self,
        residency_set: &ProtocolObject<dyn MTLResidencySet>,
    )
       where Self: Sized + Message { ... }
    unsafe fn addResidencySets_count(
        &self,
        residency_sets: NonNull<NonNull<ProtocolObject<dyn MTLResidencySet>>>,
        count: NSUInteger,
    )
       where Self: Sized + Message { ... }
    fn removeResidencySet(
        &self,
        residency_set: &ProtocolObject<dyn MTLResidencySet>,
    )
       where Self: Sized + Message { ... }
    unsafe fn removeResidencySets_count(
        &self,
        residency_sets: NonNull<NonNull<ProtocolObject<dyn MTLResidencySet>>>,
        count: NSUInteger,
    )
       where Self: Sized + Message { ... }
    unsafe fn updateTextureMappings_heap_operations_count(
        &self,
        texture: &ProtocolObject<dyn MTLTexture>,
        heap: Option<&ProtocolObject<dyn MTLHeap>>,
        operations: NonNull<MTL4UpdateSparseTextureMappingOperation>,
        count: NSUInteger,
    )
       where Self: Sized + Message { ... }
    unsafe fn copyTextureMappingsFromTexture_toTexture_operations_count(
        &self,
        source_texture: &ProtocolObject<dyn MTLTexture>,
        destination_texture: &ProtocolObject<dyn MTLTexture>,
        operations: NonNull<MTL4CopySparseTextureMappingOperation>,
        count: NSUInteger,
    )
       where Self: Sized + Message { ... }
    unsafe fn updateBufferMappings_heap_operations_count(
        &self,
        buffer: &ProtocolObject<dyn MTLBuffer>,
        heap: Option<&ProtocolObject<dyn MTLHeap>>,
        operations: NonNull<MTL4UpdateSparseBufferMappingOperation>,
        count: NSUInteger,
    )
       where Self: Sized + Message { ... }
    unsafe fn copyBufferMappingsFromBuffer_toBuffer_operations_count(
        &self,
        source_buffer: &ProtocolObject<dyn MTLBuffer>,
        destination_buffer: &ProtocolObject<dyn MTLBuffer>,
        operations: NonNull<MTL4CopySparseBufferMappingOperation>,
        count: NSUInteger,
    )
       where Self: Sized + Message { ... }
}

Available on crate feature MTL4CommandQueue only.

An abstraction representing a command queue that you use commit and synchronize command buffers and to perform other GPU operations.

See also Apple’s documentation

Provided Methods

fn device(&self) -> Retained<ProtocolObject<dyn MTLDevice>>

where Self: Sized + Message,

Available on crate feature MTLDevice only.

Returns the GPU device that the command queue belongs to.

fn label(&self) -> Option<Retained<NSString>>

where Self: Sized + Message,

Obtains this queue’s optional label for debugging purposes.

unsafe fn commit_count( &self, command_buffers: NonNull<NonNull<ProtocolObject<dyn MTL4CommandBuffer>>>, count: NSUInteger, )

where Self: Sized + Message,

Available on crate feature MTL4CommandBuffer only.

Enqueues an array of command buffers for execution.

The order in which you sort the command buffers in the array is meaningful, especially when it contains suspending/resuming render passes. A suspending/resuming render pass is a render pass you create by calling MTL4CommandBuffer/renderCommandEncoderWithDescriptor:options:, and provide MTL4RenderEncoderOptionSuspending or MTL4RenderEncoderOptionResuming for the options parameter.

If your command buffers contain suspend/resume render passes, ensure that the first command buffer only suspends, and the last one only resumes. Additionally, make sure that all intermediate command buffers are both suspending and resuming.

• Parameters:
• commandBuffers: an array of MTL4CommandBuffer.
• count: the number of MTL4CommandBuffer instances in the commandBuffers array.

Safety

• command_buffers must be a valid pointer.
• count might not be bounds-checked.

unsafe fn commit_count_options( &self, command_buffers: NonNull<NonNull<ProtocolObject<dyn MTL4CommandBuffer>>>, count: NSUInteger, options: &MTL4CommitOptions, )

where Self: Sized + Message,

Available on crate feature MTL4CommandBuffer only.

Enqueues an array of command buffer instances for execution with a set of options.

Provide an MTL4CommitOptions instance to configure the commit operation.

The order in which you sort the command buffers in the array is meaningful, especially when it contains suspending/resuming render passes. A suspending/resuming render pass is a render pass you create by calling MTL4CommandBuffer/renderCommandEncoderWithDescriptor:options:, and provide MTL4RenderEncoderOptionSuspending or MTL4RenderEncoderOptionResuming for the options parameter.

If your command buffers contain suspend/resume render passes, ensure that the first command buffer only suspends, and the last one only resumes. Additionally, make sure that all intermediate command buffers are both suspending and resuming.

When you commit work from multiple threads, modifying and reusing the same options instance, you are responsible for externally synchronizing access to it.

• Parameters:
• commandBuffers: an array of MTL4CommandBuffer.
• count: the number of MTL4CommandBuffer instances in the commandBuffers array.
• options: an instance of MTL4CommitOptions that configures the commit operation.

Safety

• command_buffers must be a valid pointer.
• count might not be bounds-checked.

fn signalEvent_value(&self, event: &ProtocolObject<dyn MTLEvent>, value: u64)

where Self: Sized + Message,

Available on crate feature MTLEvent only.

Schedules an operation to signal a GPU event with a specific value after all GPU work prior to this point is complete.

• Parameters:
• event: MTLEvent to signal.
• value: the value to signal the MTLEvent with.

fn waitForEvent_value(&self, event: &ProtocolObject<dyn MTLEvent>, value: u64)

where Self: Sized + Message,

Available on crate feature MTLEvent only.

Schedules an operation to wait for a GPU event of a specific value before continuing to execute any future GPU work.

• Parameters:
• event: MTLEvent to wait on.
• value: the specific value to wait for.

fn signalDrawable(&self, drawable: &ProtocolObject<dyn MTLDrawable>)

where Self: Sized + Message,

Available on crate feature MTLDrawable only.

Schedules a signal operation on the command queue to indicate when rendering to a Metal drawable is complete.

Signaling when rendering to a MTLDrawable instance is complete indicates that it’s safe to present it to the display.

You are responsible for calling this method after committing all command buffers that contain commands targeting this drawable, and before calling MTLDrawable/present, MTLDrawable/presentAtTime:, or MTLDrawable/presentAfterMinimumDuration:.

• Note: This method doesn’t trigger the presentation of the drawable, and fails if you call it after any of the present methods, or if you call it multiple times.

Metal doesn’t guarantee that command buffers you commit to the command queue after calling this method execute before presentation.

• Parameters:
• drawable: MTLDrawable instance to signal.

fn waitForDrawable(&self, drawable: &ProtocolObject<dyn MTLDrawable>)

where Self: Sized + Message,

Available on crate feature MTLDrawable only.

Schedules a wait operation on the command queue to ensure the display is no longer using a specific Metal drawable.

Use this method to ensure the display is no longer using a MTLDrawable instance before executing any subsequent commands.

This method returns immediately and doesn’t perform any synchronization on the current thread. You are responsible for calling this method before committing any command buffers containing commands that target this drawable.

Call this method multiple times if you commit your command buffers to multiple command queues.

• Parameters:
• drawable: MTLDrawable instance to signal.

fn addResidencySet(&self, residency_set: &ProtocolObject<dyn MTLResidencySet>)

where Self: Sized + Message,

Available on crate feature MTLResidencySet only.

Marks a residency set as part of this command queue.

Ensures that Metal makes the residency set resident during the execution of all command buffers you commit to this command queue.

Each command queue supports up to 32 unique residency set instances.

• Parameter residencySet: MTLResidencySet to add to the command queue.

unsafe fn addResidencySets_count( &self, residency_sets: NonNull<NonNull<ProtocolObject<dyn MTLResidencySet>>>, count: NSUInteger, )

where Self: Sized + Message,

Available on crate feature MTLResidencySet only.

Marks an array of residency sets as part of this command queue.

Ensures that Metal makes the residency set resident during the execution of all command buffers you commit to this command queue.

Each command queue supports up to 32 unique residency set instances.

• Parameters:
• residencySets: Array of MTLResidencySet instances to add to the command queue.
• count: Number of MTLResidencySet instances in the array.

Safety

• residency_sets must be a valid pointer.
• count might not be bounds-checked.

fn removeResidencySet( &self, residency_set: &ProtocolObject<dyn MTLResidencySet>, )

where Self: Sized + Message,

Available on crate feature MTLResidencySet only.

Removes a residency set from the command queue.

After calling this method ensures only the remaining residency sets remain resident during the execution of the command buffers you commit this command queue.

• Parameter residencySet: MTLResidencySet instance to remove from the command queue.

unsafe fn removeResidencySets_count( &self, residency_sets: NonNull<NonNull<ProtocolObject<dyn MTLResidencySet>>>, count: NSUInteger, )

where Self: Sized + Message,

Available on crate feature MTLResidencySet only.

Removes multiple residency sets from the command queue.

After calling this method ensures only the remaining residency sets remain resident during the execution of the command buffers you commit this command queue.

• Parameters:
• residencySets: Array of MTLResidencySet instances to remove from the command queue.
• count: Number of MTLResidencySet instances in the array.

Safety

• residency_sets must be a valid pointer.
• count might not be bounds-checked.

unsafe fn updateTextureMappings_heap_operations_count( &self, texture: &ProtocolObject<dyn MTLTexture>, heap: Option<&ProtocolObject<dyn MTLHeap>>, operations: NonNull<MTL4UpdateSparseTextureMappingOperation>, count: NSUInteger, )

where Self: Sized + Message,

Available on crate features MTLAllocation and MTLHeap and MTLResource and MTLResourceStateCommandEncoder and MTLTexture and MTLTypes only.

Updates multiple regions within a placement sparse texture to alias specific tiles of a Metal heap.

You can provide a nil parameter to the heap argument only if when you perform unmap operations. Otherwise, you are responsible for ensuring the heap is non-nil and has a MTLHeapDescriptor/maxCompatiblePlacementSparsePageSize of at least the texture’s MTLTextureDescriptor/placementSparsePageSize.

When performing a sparse mapping update, you are responsible for issuing a barrier against stage MTLStageResourceState.

You can determine the sparse texture tier by calling MTLTexture/sparseTextureTier.

• Parameters:
• texture: A placement sparse MTLTexture.
• heap: MTLHeap you allocate with type MTLHeapType/MTLHeapTypePlacement.
• operations: An array of MTL4UpdateSparseTextureMappingOperation instances to perform.
• count: Number of operations to perform.

Safety

• texture may need to be synchronized.
• texture may be unretained, you must ensure it is kept alive while in use.
• operations must be a valid pointer.
• count might not be bounds-checked.

unsafe fn copyTextureMappingsFromTexture_toTexture_operations_count( &self, source_texture: &ProtocolObject<dyn MTLTexture>, destination_texture: &ProtocolObject<dyn MTLTexture>, operations: NonNull<MTL4CopySparseTextureMappingOperation>, count: NSUInteger, )

where Self: Sized + Message,

Available on crate features MTLAllocation and MTLResource and MTLTexture and MTLTypes only.

Copies multiple regions within a source placement sparse texture to a destination placement sparse texture.

You are responsible for ensuring the source and destination textures have the same MTLTextureDescriptor/placementSparsePageSize.

Additionally, you are responsible for ensuring that the source and destination textures don’t use the same aliased tiles at the same time.

• Note: If a sparse texture and a sparse buffer share the same backing tiles, these don’t provide you you with meaningful views of the other resource’s data.

• Parameters:

• sourceTexture: The source placement sparse MTLTexture.

• destinationTexture: The destination placement sparse MTLTexture.

• operations: An array of MTL4CopySparseTextureMappingOperation instances to perform.

• count: Number of operations to perform.

Safety

• source_texture may need to be synchronized.
• source_texture may be unretained, you must ensure it is kept alive while in use.
• destination_texture may need to be synchronized.
• destination_texture may be unretained, you must ensure it is kept alive while in use.
• operations must be a valid pointer.
• count might not be bounds-checked.

unsafe fn updateBufferMappings_heap_operations_count( &self, buffer: &ProtocolObject<dyn MTLBuffer>, heap: Option<&ProtocolObject<dyn MTLHeap>>, operations: NonNull<MTL4UpdateSparseBufferMappingOperation>, count: NSUInteger, )

where Self: Sized + Message,

Available on crate features MTLAllocation and MTLBuffer and MTLHeap and MTLResource and MTLResourceStateCommandEncoder only.

Updates multiple regions within a placement sparse buffer to alias specific tiles from a Metal heap.

You can provide a nil parameter to the heap argument only when you perform unmap operations. Otherwise, you are responsible for ensuring parameter heap references an MTLHeap that has a MTLHeapDescriptor/maxCompatiblePlacementSparsePageSize of at least the buffer’s placementSparsePageSize you assign when creating the sparse buffer via MTLDevice/newBufferWithLength:options:placementSparsePageSize:.

• Parameters:
• buffer: A placement sparse MTLBuffer.
• heap: An MTLHeap you allocate with type MTLHeapType/MTLHeapTypePlacement.
• operations: An array of MTL4UpdateSparseBufferMappingOperation instances to perform.
• count: Number of operations to perform.

Safety

• buffer may need to be synchronized.
• buffer may be unretained, you must ensure it is kept alive while in use.
• buffer contents should be of the correct type.
• operations must be a valid pointer.
• count might not be bounds-checked.

unsafe fn copyBufferMappingsFromBuffer_toBuffer_operations_count( &self, source_buffer: &ProtocolObject<dyn MTLBuffer>, destination_buffer: &ProtocolObject<dyn MTLBuffer>, operations: NonNull<MTL4CopySparseBufferMappingOperation>, count: NSUInteger, )

where Self: Sized + Message,

Available on crate features MTLAllocation and MTLBuffer and MTLResource only.

Copies multiple offsets within a source placement sparse buffer to a destination placement sparse buffer.

You are responsible for ensuring the source destination sparse buffers have the same placementSparsePageSize when you create them via MTLDevice/newBufferWithLength:options:placementSparsePageSize:.

Additionally, you are responsible for ensuring both the source and destination sparse buffers don’t use the same aliased tiles at the same time.

• Note: If a sparse texture and a sparse buffer share the same backing tiles, these don’t provide you with meaningful views of the other resource’s data.

• Parameters:

• sourceBuffer: The source placement sparse MTLBuffer.

• destinationBuffer: The destination placement sparse MTLBuffer.

• operations: An array of MTL4CopySparseBufferMappingOperation instances to perform.

• count: Number of operations to perform.

Safety

• source_buffer may need to be synchronized.
• source_buffer may be unretained, you must ensure it is kept alive while in use.
• source_buffer contents should be of the correct type.
• destination_buffer may need to be synchronized.
• destination_buffer may be unretained, you must ensure it is kept alive while in use.
• destination_buffer contents should be of the correct type.
• operations must be a valid pointer.
• count might not be bounds-checked.

Trait Implementations

impl ProtocolType for dyn MTL4CommandQueue

const NAME: &'static str = "MTL4CommandQueue"

The name of the Objective-C protocol that this type represents.

fn protocol() -> Option<&'static AnyProtocol>

Get a reference to the Objective-C protocol object that this type represents.

impl<T> ImplementedBy<T> for dyn MTL4CommandQueue

where T: ?Sized + Message + MTL4CommandQueue,

Implementations on Foreign Types

impl<T> MTL4CommandQueue for ProtocolObject<T>

where T: ?Sized + MTL4CommandQueue,

Implementors