Struct Compiler 

pub struct Compiler(/* private fields */);

MTL4 shader compiler.

C++ equivalent: MTL4::Compiler

Compiler provides methods for compiling shaders, creating pipelines, and managing binary functions.

Implementations

impl Compiler

pub unsafe fn from_raw(ptr: *mut c_void) -> Option<Self>

Create a Compiler from a raw pointer.

pub fn as_raw(&self) -> *mut c_void

Get the raw pointer.

pub fn device(&self) -> Option<Device>

Get the device.

C++ equivalent: MTL::Device* device() const

pub fn label(&self) -> Option<String>

Get the label.

C++ equivalent: NS::String* label() const

pub fn pipeline_data_set_serializer(&self) -> Option<PipelineDataSetSerializer>

Get the pipeline data set serializer.

C++ equivalent: PipelineDataSetSerializer* pipelineDataSetSerializer() const

pub fn new_library( &self, descriptor: &LibraryDescriptor, ) -> Result<Library, Error>

Create a new library synchronously.

C++ equivalent: MTL::Library* newLibrary(const MTL4::LibraryDescriptor*, NS::Error**)

pub fn new_binary_function( &self, descriptor: &BinaryFunctionDescriptor, options: Option<&CompilerTaskOptions>, ) -> Result<BinaryFunction, Error>

Create a new binary function synchronously.

C++ equivalent: BinaryFunction* newBinaryFunction(..., NS::Error**)

pub fn new_compute_pipeline_state( &self, descriptor: &ComputePipelineDescriptor, options: Option<&CompilerTaskOptions>, ) -> Result<ComputePipelineState, Error>

Create a new compute pipeline state synchronously.

C++ equivalent: MTL::ComputePipelineState* newComputePipelineState(..., NS::Error**)

pub fn new_compute_pipeline_state_with_dynamic_linking( &self, descriptor: &ComputePipelineDescriptor, dynamic_linking: &PipelineStageDynamicLinkingDescriptor, options: Option<&CompilerTaskOptions>, ) -> Result<ComputePipelineState, Error>

Create a new compute pipeline state with dynamic linking synchronously.

C++ equivalent: MTL::ComputePipelineState* newComputePipelineState(..., dynamicLinkingDescriptor, ..., NS::Error**)

pub fn new_render_pipeline_state( &self, descriptor: &PipelineDescriptor, options: Option<&CompilerTaskOptions>, ) -> Result<RenderPipelineState, Error>

Create a new render pipeline state synchronously.

C++ equivalent: MTL::RenderPipelineState* newRenderPipelineState(..., NS::Error**)

pub fn new_render_pipeline_state_with_dynamic_linking( &self, descriptor: &PipelineDescriptor, dynamic_linking: &RenderPipelineDynamicLinkingDescriptor, options: Option<&CompilerTaskOptions>, ) -> Result<RenderPipelineState, Error>

Create a new render pipeline state with dynamic linking synchronously.

C++ equivalent: MTL::RenderPipelineState* newRenderPipelineState(..., dynamicLinkingDescriptor, ..., NS::Error**)

pub fn new_render_pipeline_state_by_specialization( &self, descriptor: &PipelineDescriptor, pipeline: &RenderPipelineState, ) -> Result<RenderPipelineState, Error>

Create a new render pipeline state by specialization.

C++ equivalent: MTL::RenderPipelineState* newRenderPipelineStateBySpecialization(...)

pub fn new_dynamic_library_from_library( &self, library: &Library, ) -> Result<*mut c_void, Error>

Create a new dynamic library from a library.

C++ equivalent: MTL::DynamicLibrary* newDynamicLibrary(const MTL::Library*, NS::Error**)

pub fn new_dynamic_library_from_url( &self, url: *const c_void, ) -> Result<*mut c_void, Error>

Create a new dynamic library from a URL.

C++ equivalent: MTL::DynamicLibrary* newDynamicLibrary(const NS::URL*, NS::Error**)

pub fn new_library_async<F>( &self, descriptor: &LibraryDescriptor, completion_handler: F, ) -> Option<CompilerTask>

where F: Fn(Option<Library>, Option<Error>) + Send + 'static,

Create a new library asynchronously with a completion handler.

C++ equivalent: CompilerTask* newLibrary(const LibraryDescriptor*, NewLibraryCompletionHandler)

pub fn new_binary_function_async<F>( &self, descriptor: &BinaryFunctionDescriptor, options: Option<&CompilerTaskOptions>, completion_handler: F, ) -> Option<CompilerTask>

where F: Fn(Option<BinaryFunction>, Option<Error>) + Send + 'static,

Create a new binary function asynchronously with a completion handler.

C++ equivalent: CompilerTask* newBinaryFunction(const BinaryFunctionDescriptor*, CompilerTaskOptions*, NewBinaryFunctionCompletionHandler)

pub fn new_compute_pipeline_state_async<F>( &self, descriptor: &ComputePipelineDescriptor, options: Option<&CompilerTaskOptions>, completion_handler: F, ) -> Option<CompilerTask>

where F: Fn(Option<ComputePipelineState>, Option<Error>) + Send + 'static,

Create a new compute pipeline state asynchronously with a completion handler.

C++ equivalent: CompilerTask* newComputePipelineState(const ComputePipelineDescriptor*, CompilerTaskOptions*, NewComputePipelineStateCompletionHandler)

pub fn new_render_pipeline_state_async<F>( &self, descriptor: &PipelineDescriptor, options: Option<&CompilerTaskOptions>, completion_handler: F, ) -> Option<CompilerTask>

where F: Fn(Option<RenderPipelineState>, Option<Error>) + Send + 'static,

Create a new render pipeline state asynchronously with a completion handler.

C++ equivalent: CompilerTask* newRenderPipelineState(const PipelineDescriptor*, CompilerTaskOptions*, NewRenderPipelineStateCompletionHandler)

pub fn new_render_pipeline_state_by_specialization_async<F>( &self, descriptor: &PipelineDescriptor, pipeline: &RenderPipelineState, completion_handler: F, ) -> Option<CompilerTask>

where F: Fn(Option<RenderPipelineState>, Option<Error>) + Send + 'static,

Create a new render pipeline state by specialization asynchronously.

C++ equivalent: CompilerTask* newRenderPipelineStateBySpecialization(..., NewRenderPipelineStateCompletionHandler)

pub fn new_dynamic_library_from_library_async<F>( &self, library: &Library, completion_handler: F, ) -> Option<CompilerTask>

where F: Fn(Option<DynamicLibrary>, Option<Error>) + Send + 'static,

Create a new dynamic library from a library asynchronously.

C++ equivalent: CompilerTask* newDynamicLibrary(const Library*, NewDynamicLibraryCompletionHandler)

pub unsafe fn new_dynamic_library_from_url_async<F>( &self, url: *const c_void, completion_handler: F, ) -> Option<CompilerTask>

where F: Fn(Option<DynamicLibrary>, Option<Error>) + Send + 'static,

Create a new dynamic library from a URL asynchronously.

C++ equivalent: CompilerTask* newDynamicLibrary(const NS::URL*, NewDynamicLibraryCompletionHandler)

Safety

The URL pointer must be valid.

pub fn new_compute_pipeline_state_with_dynamic_linking_async<F>( &self, descriptor: &ComputePipelineDescriptor, dynamic_linking: &PipelineStageDynamicLinkingDescriptor, options: Option<&CompilerTaskOptions>, completion_handler: F, ) -> Option<CompilerTask>

where F: Fn(Option<ComputePipelineState>, Option<Error>) + Send + 'static,

Create a new compute pipeline state with dynamic linking asynchronously.

C++ equivalent: CompilerTask* newComputePipelineState(..., dynamicLinkingDescriptor, ..., completionHandler)

pub fn new_render_pipeline_state_with_dynamic_linking_async<F>( &self, descriptor: &PipelineDescriptor, dynamic_linking: &RenderPipelineDynamicLinkingDescriptor, options: Option<&CompilerTaskOptions>, completion_handler: F, ) -> Option<CompilerTask>

where F: Fn(Option<RenderPipelineState>, Option<Error>) + Send + 'static,

Create a new render pipeline state with dynamic linking asynchronously.

C++ equivalent: CompilerTask* newRenderPipelineState(..., dynamicLinkingDescriptor, ..., completionHandler)

pub fn new_machine_learning_pipeline_state( &self, descriptor: &MachineLearningPipelineDescriptor, options: Option<&CompilerTaskOptions>, ) -> Result<MachineLearningPipelineState, Error>

Create a new machine learning pipeline state synchronously.

C++ equivalent: MTL4::MachineLearningPipelineState* newMachineLearningPipelineState(..., NS::Error**)

pub fn new_machine_learning_pipeline_state_async<F>( &self, descriptor: &MachineLearningPipelineDescriptor, options: Option<&CompilerTaskOptions>, completion_handler: F, ) -> Option<CompilerTask>

where F: Fn(Option<MachineLearningPipelineState>, Option<Error>) + Send + 'static,

Create a new machine learning pipeline state asynchronously.

C++ equivalent: CompilerTask* newMachineLearningPipelineState(..., completionHandler)

Trait Implementations

impl Clone for Compiler

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Compiler

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Compiler

fn drop(&mut self)

Executes the destructor for this type.

impl Referencing for Compiler

fn as_ptr(&self) -> *const c_void

Get the raw pointer to the Objective-C object.

fn as_mut_ptr(&self) -> *mut c_void

Get the raw mutable pointer to the Objective-C object.

fn retain(&self) -> Self

where Self: Clone,

Retain the object, incrementing its reference count.

fn release(&self)

Release the object, decrementing its reference count.

fn autorelease(&self) -> Self

where Self: Clone,

Autorelease the object.

fn retain_count(&self) -> usize

Get the retain count of the object.

impl Send for Compiler

impl Sync for Compiler