objc2-metal-performance-shaders 0.3.2

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
use objc2_foundation::*;
use objc2_metal::*;

use crate::*;

/// A description of each copy operation
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsmatrixcopyoffsets?language=objc)
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MPSMatrixCopyOffsets {
    /// offset to start of source region to read in rows
    pub sourceRowOffset: u32,
    /// offset to start of source region to read in columns
    pub sourceColumnOffset: u32,
    /// offset to start of destination region to read in rows
    pub destinationRowOffset: u32,
    /// offset to start of destination region to read in columns
    pub destinationColumnOffset: u32,
}

unsafe impl Encode for MPSMatrixCopyOffsets {
    const ENCODING: Encoding = Encoding::Struct(
        "?",
        &[
            <u32>::ENCODING,
            <u32>::ENCODING,
            <u32>::ENCODING,
            <u32>::ENCODING,
        ],
    );
}

unsafe impl RefEncode for MPSMatrixCopyOffsets {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

extern_class!(
    /// A list of copy operations
    ///
    /// The MPSMatrixCopy filter can do multiple copy operations.  For RNN filters, these
    /// copies are often small, and are more efficient when grouped together.
    /// The MPSMatriceCopyDescriptor provides a container to list the operations.
    /// The operations occur in any order, and may not alias.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsmatrixcopydescriptor?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSMatrixCopyDescriptor;
);

extern_conformance!(
    unsafe impl NSObjectProtocol for MPSMatrixCopyDescriptor {}
);

impl MPSMatrixCopyDescriptor {
    extern_methods!(
        #[cfg(feature = "MPSCore")]
        /// convenience allocator for single copies
        #[unsafe(method(descriptorWithSourceMatrix:destinationMatrix:offsets:))]
        #[unsafe(method_family = none)]
        pub unsafe fn descriptorWithSourceMatrix_destinationMatrix_offsets(
            source_matrix: &MPSMatrix,
            destination_matrix: &MPSMatrix,
            offsets: MPSMatrixCopyOffsets,
        ) -> Retained<Self>;

        /// initialize a MPSMatrixCopyDescriptor with default values.
        ///
        /// Use -setCopyOperationAtIndex:sourceMatrix:destinationMatrix:copyOffsets
        /// to initialize. All indices must be initialized before use.
        ///
        /// Parameter `device`: The device on which the copy will be performed
        ///
        /// Parameter `count`: The number of copy operations the object will encode
        ///
        /// Returns: A MPSMatrixCopyDescriptor. It still needs to be initialized with
        /// -setCopyOperationAtIndex:sourceMatrix:destinationMatrix:copyOffsets
        #[unsafe(method(initWithDevice:count:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithDevice_count(
            this: Allocated<Self>,
            device: &ProtocolObject<dyn MTLDevice>,
            count: NSUInteger,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCore")]
        /// Initialize a MPSMatrixCopyDescriptor using offsets generated on the CPU
        ///
        /// This is for one at a time intialization of the copy operations
        ///
        /// Parameter `index`: The index of the copy operation
        ///
        /// Parameter `sourceMatrix`: The source matrix for this copy operation
        ///
        /// Parameter `destinationMatrix`: The destination matrix for this copy operation
        ///
        /// Parameter `offsets`: The offsets to use for the copy operation
        #[unsafe(method(setCopyOperationAtIndex:sourceMatrix:destinationMatrix:offsets:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setCopyOperationAtIndex_sourceMatrix_destinationMatrix_offsets(
            &self,
            index: NSUInteger,
            source_matrix: &MPSMatrix,
            destination_matrix: &MPSMatrix,
            offsets: MPSMatrixCopyOffsets,
        );

        #[cfg(feature = "MPSCore")]
        /// Initialize a MPSMatrixCopyDescriptor using offsets generated on the GPU
        ///
        /// Use this method when the offsets needed are coming from GPU based computation.
        ///
        /// Parameter `sourceMatrices`: A list of matrices from which the matrix data is read
        ///
        /// Parameter `destinationMatrices`: A list of matrices to which to write the data. The count
        /// must match the number of source matrices.
        ///
        /// Parameter `offsets`: A MPSVector of type MPSDataTypeUInt32 containing the list of
        /// offsets, stored as a packed array of MPSMatrixCopyOffsets.
        ///
        /// Parameter `byteOffset`: A byte offset into the offsets vector where the data starts in 'offsets'.
        /// This value must be a multiple of 16.
        ///
        /// Returns: A valid MPSMatrixCopyDescriptor to represent the list of copy operations
        #[unsafe(method(initWithSourceMatrices:destinationMatrices:offsetVector:offset:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceMatrices_destinationMatrices_offsetVector_offset(
            this: Allocated<Self>,
            source_matrices: &NSArray<MPSMatrix>,
            destination_matrices: &NSArray<MPSMatrix>,
            offsets: Option<&MPSVector>,
            byte_offset: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSMatrixCopyDescriptor {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsmatrixcopy?language=objc)
    #[unsafe(super(MPSKernel, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(all(feature = "MPSCore", feature = "MPSKernel"))]
    pub struct MPSMatrixCopy;
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel"))]
extern_conformance!(
    unsafe impl NSCoding for MPSMatrixCopy {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel"))]
extern_conformance!(
    unsafe impl NSCopying for MPSMatrixCopy {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel"))]
unsafe impl CopyingHelper for MPSMatrixCopy {
    type Result = Self;
}

#[cfg(all(feature = "MPSCore", feature = "MPSKernel"))]
extern_conformance!(
    unsafe impl NSObjectProtocol for MPSMatrixCopy {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel"))]
extern_conformance!(
    unsafe impl NSSecureCoding for MPSMatrixCopy {}
);

#[cfg(all(feature = "MPSCore", feature = "MPSKernel"))]
impl MPSMatrixCopy {
    extern_methods!(
        #[unsafe(method(initWithDevice:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithDevice(
            this: Allocated<Self>,
            device: &ProtocolObject<dyn MTLDevice>,
        ) -> Retained<Self>;

        /// Initialize a copy operator
        ///
        /// Parameter `copyRows`: The number of rows to copy for each copy operation
        ///
        /// Parameter `copyColumns`: The number of matrix columns to copy in each copy operation
        ///
        /// Parameter `sourcesAreTransposed`: If YES, the sources are in column major storage order
        ///
        /// Parameter `destinationsAreTransposed`: If YES, the destinations are in column major storage order
        #[unsafe(method(initWithDevice:copyRows:copyColumns:sourcesAreTransposed:destinationsAreTransposed:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithDevice_copyRows_copyColumns_sourcesAreTransposed_destinationsAreTransposed(
            this: Allocated<Self>,
            device: &ProtocolObject<dyn MTLDevice>,
            copy_rows: NSUInteger,
            copy_columns: NSUInteger,
            sources_are_transposed: bool,
            destinations_are_transposed: bool,
        ) -> Retained<Self>;

        /// The number of rows to copy for each copy operation
        #[unsafe(method(copyRows))]
        #[unsafe(method_family = none)]
        pub unsafe fn copyRows(&self) -> NSUInteger;

        /// The number of columns to copy for each copy operation
        #[unsafe(method(copyColumns))]
        #[unsafe(method_family = none)]
        pub unsafe fn copyColumns(&self) -> NSUInteger;

        /// If YES, the sources are in row major storage order
        #[unsafe(method(sourcesAreTransposed))]
        #[unsafe(method_family = none)]
        pub unsafe fn sourcesAreTransposed(&self) -> bool;

        /// If YES, the destinations are in row major storage order
        #[unsafe(method(destinationsAreTransposed))]
        #[unsafe(method_family = none)]
        pub unsafe fn destinationsAreTransposed(&self) -> bool;

        /// Encode the copy operations to the command buffer
        ///
        ///
        /// Parameter `commandBuffer`: A valid MTLCommandBuffer to receive the encoded kernel.
        ///
        ///
        /// Parameter `copyDescriptor`: The descriptor that defines the copy operator
        #[unsafe(method(encodeToCommandBuffer:copyDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn encodeToCommandBuffer_copyDescriptor(
            &self,
            command_buffer: &ProtocolObject<dyn MTLCommandBuffer>,
            copy_descriptor: &MPSMatrixCopyDescriptor,
        );

        /// Encode the copy operations to the command buffer.
        /// This of the encode version support permuting the outputs with custom vectors of indices.
        /// The permutations are defined on the destination indices and are the same for each copy
        /// operation.
        ///
        ///
        /// Parameter `commandBuffer`: A valid MTLCommandBuffer to receive the encoded kernel.
        ///
        ///
        /// Parameter `copyDescriptor`: The descriptor that defines the copy operator
        ///
        ///
        /// Parameter `rowPermuteIndices`: If not nil then the output row index is
        /// 'rowPermuteIndices[i] + rowOffset' instead of 'i + rowOffset',
        /// where 'i' is the local row index of the copy operation.
        /// Note: if destinationsAreTransposed is set to YES then the destination
        /// transpose is performed before permutations.
        ///
        ///
        /// Parameter `rowPermuteOffset`: Offset in numbers to apply to the 'rowPermuteIndices' vector.
        ///
        ///
        /// Parameter `columnPermuteIndices`: If not nil then the output column index is
        /// 'columnPermuteIndices[i] + columnOffset' instead of 'i + columnOffset',
        /// where 'i' is the local column index of the copy operation.
        /// Note: if destinationsAreTransposed is set to YES then the destination
        /// transpose is performed before permutations.
        ///
        ///
        /// Parameter `columnPermuteOffset`: Offset in numbers to apply to the 'columnPermuteIndices' vector.
        #[unsafe(method(encodeToCommandBuffer:copyDescriptor:rowPermuteIndices:rowPermuteOffset:columnPermuteIndices:columnPermuteOffset:))]
        #[unsafe(method_family = none)]
        pub unsafe fn encodeToCommandBuffer_copyDescriptor_rowPermuteIndices_rowPermuteOffset_columnPermuteIndices_columnPermuteOffset(
            &self,
            command_buffer: &ProtocolObject<dyn MTLCommandBuffer>,
            copy_descriptor: &MPSMatrixCopyDescriptor,
            row_permute_indices: Option<&MPSVector>,
            row_permute_offset: NSUInteger,
            column_permute_indices: Option<&MPSVector>,
            column_permute_offset: NSUInteger,
        );

        /// NSSecureCoding compatability
        ///
        /// See
        /// MPSKernel#initWithCoder.
        /// Parameter `aDecoder`: The NSCoder subclass with your serialized MPSMatrixLookUpAndCopy
        ///
        /// Parameter `device`: The MTLDevice on which to make the MPSMatrixLookUpAndCopy
        ///
        /// Returns: A new MPSMatrixLookUpAndCopy object, or nil if failure.
        ///
        /// # Safety
        ///
        /// `a_decoder` possibly has further requirements.
        #[unsafe(method(initWithCoder:device:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCoder_device(
            this: Allocated<Self>,
            a_decoder: &NSCoder,
            device: &ProtocolObject<dyn MTLDevice>,
        ) -> Option<Retained<Self>>;
    );
}

/// Methods declared on superclass `MPSKernel`.
#[cfg(all(feature = "MPSCore", feature = "MPSKernel"))]
impl MPSMatrixCopy {
    extern_methods!(
        /// Called by NSCoder to decode MPSKernels
        ///
        /// This isn't the right interface to decode a MPSKernel, but
        /// it is the one that NSCoder uses. To enable your NSCoder
        /// (e.g. NSKeyedUnarchiver) to set which device to use
        /// extend the object to adopt the MPSDeviceProvider
        /// protocol. Otherwise, the Metal system default device
        /// will be used.
        ///
        /// # Safety
        ///
        /// `a_decoder` possibly has further requirements.
        #[unsafe(method(initWithCoder:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCoder(
            this: Allocated<Self>,
            a_decoder: &NSCoder,
        ) -> Option<Retained<Self>>;
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(all(feature = "MPSCore", feature = "MPSKernel"))]
impl MPSMatrixCopy {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}