#![allow(non_camel_case_types)]
#![allow(dead_code)]
pub(crate) mod foundation {
pub use metal_rust_ffi::__private::structs::OperatingSystemVersion;
pub use metal_rust_ffi::__private::structs::Range;
pub use metal_rust_ffi::__private::values::ActivityOptions;
pub use metal_rust_ffi::__private::values::ComparisonResult;
pub use metal_rust_ffi::__private::values::ProcessInfoThermalState;
pub use metal_rust_ffi::__private::values::StringCompareOptions;
pub use metal_rust_ffi::__private::values::StringEncoding;
pub type Integer = isize;
pub type TimeInterval = f64;
pub type UInteger = usize;
pub type unichar = u16;
}
pub(crate) mod metal {
pub use metal_rust_ffi::__private::structs::AccelerationStructureInstanceDescriptor;
pub use metal_rust_ffi::__private::structs::AccelerationStructureMotionInstanceDescriptor;
pub use metal_rust_ffi::__private::structs::AccelerationStructureSizes;
pub use metal_rust_ffi::__private::structs::AccelerationStructureUserIDInstanceDescriptor;
pub use metal_rust_ffi::__private::structs::AxisAlignedBoundingBox;
pub use metal_rust_ffi::__private::structs::ComponentTransform;
pub use metal_rust_ffi::__private::structs::CounterResultStageUtilization;
pub use metal_rust_ffi::__private::structs::CounterResultStatistic;
pub use metal_rust_ffi::__private::structs::CounterResultTimestamp;
pub use metal_rust_ffi::__private::structs::DispatchThreadgroupsIndirectArguments;
pub use metal_rust_ffi::__private::structs::DispatchThreadsIndirectArguments;
pub use metal_rust_ffi::__private::structs::DrawIndexedPrimitivesIndirectArguments;
pub use metal_rust_ffi::__private::structs::DrawPatchIndirectArguments;
pub use metal_rust_ffi::__private::structs::DrawPrimitivesIndirectArguments;
pub use metal_rust_ffi::__private::structs::IndirectAccelerationStructureInstanceDescriptor;
pub use metal_rust_ffi::__private::structs::IndirectAccelerationStructureMotionInstanceDescriptor;
pub use metal_rust_ffi::__private::structs::IndirectCommandBufferExecutionRange;
pub use metal_rust_ffi::__private::structs::IntersectionFunctionBufferArguments;
pub use metal_rust_ffi::__private::structs::MapIndirectArguments;
pub use metal_rust_ffi::__private::structs::PackedFloat3;
pub use metal_rust_ffi::__private::structs::PackedFloat4x3;
pub use metal_rust_ffi::__private::structs::PackedFloatQuaternion;
pub use metal_rust_ffi::__private::structs::QuadTessellationFactorsHalf;
pub use metal_rust_ffi::__private::structs::ResourceID;
pub use metal_rust_ffi::__private::structs::SamplePosition;
pub use metal_rust_ffi::__private::structs::ScissorRect;
pub use metal_rust_ffi::__private::structs::SizeAndAlign;
pub use metal_rust_ffi::__private::structs::StageInRegionIndirectArguments;
pub use metal_rust_ffi::__private::structs::TextureSwizzleChannels;
pub use metal_rust_ffi::__private::structs::TriangleTessellationFactorsHalf;
pub use metal_rust_ffi::__private::structs::VertexAmplificationViewMapping;
pub use metal_rust_ffi::__private::values::AccelerationStructureInstanceDescriptorType;
pub use metal_rust_ffi::__private::values::AccelerationStructureInstanceOptions;
pub use metal_rust_ffi::__private::values::AccelerationStructureRefitOptions;
pub use metal_rust_ffi::__private::values::AccelerationStructureUsage;
pub use metal_rust_ffi::__private::values::ArgumentBuffersTier;
pub use metal_rust_ffi::__private::values::ArgumentType;
pub use metal_rust_ffi::__private::values::AttributeFormat;
pub use metal_rust_ffi::__private::values::BarrierScope;
pub use metal_rust_ffi::__private::values::BinaryArchiveError;
pub use metal_rust_ffi::__private::values::BindingAccess;
pub use metal_rust_ffi::__private::values::BindingType;
pub use metal_rust_ffi::__private::values::BlendFactor;
pub use metal_rust_ffi::__private::values::BlendOperation;
pub use metal_rust_ffi::__private::values::BlitOption;
pub use metal_rust_ffi::__private::values::BufferSparseTier;
pub use metal_rust_ffi::__private::values::CPUCacheMode;
pub use metal_rust_ffi::__private::values::CaptureDestination;
pub use metal_rust_ffi::__private::values::CaptureError;
pub use metal_rust_ffi::__private::values::ColorWriteMask;
pub use metal_rust_ffi::__private::values::CommandBufferError;
pub use metal_rust_ffi::__private::values::CommandBufferErrorOption;
pub use metal_rust_ffi::__private::values::CommandEncoderErrorState;
pub use metal_rust_ffi::__private::values::CompareFunction;
pub use metal_rust_ffi::__private::values::CompileSymbolVisibility;
pub use metal_rust_ffi::__private::values::CounterSampleBufferError;
pub use metal_rust_ffi::__private::values::CounterSamplingPoint;
pub use metal_rust_ffi::__private::values::CullMode;
pub use metal_rust_ffi::__private::values::CurveBasis;
pub use metal_rust_ffi::__private::values::CurveEndCaps;
pub use metal_rust_ffi::__private::values::CurveType;
pub use metal_rust_ffi::__private::values::DataType;
pub use metal_rust_ffi::__private::values::DepthClipMode;
pub use metal_rust_ffi::__private::values::DeviceError;
pub use metal_rust_ffi::__private::values::DeviceLocation;
pub use metal_rust_ffi::__private::values::DispatchType;
pub use metal_rust_ffi::__private::values::DynamicLibraryError;
pub use metal_rust_ffi::__private::values::FeatureSet;
pub use metal_rust_ffi::__private::values::FloatingPointConversionRoundingMode;
pub use metal_rust_ffi::__private::values::FunctionLogType;
pub use metal_rust_ffi::__private::values::FunctionOptions;
pub use metal_rust_ffi::__private::values::FunctionType;
pub use metal_rust_ffi::__private::values::GPUFamily;
pub use metal_rust_ffi::__private::values::HazardTrackingMode;
pub use metal_rust_ffi::__private::values::HeapType;
pub use metal_rust_ffi::__private::values::IOCommandQueueType;
pub use metal_rust_ffi::__private::values::IOCompressionMethod;
pub use metal_rust_ffi::__private::values::IOCompressionStatus;
pub use metal_rust_ffi::__private::values::IOError;
pub use metal_rust_ffi::__private::values::IOPriority;
pub use metal_rust_ffi::__private::values::IOStatus;
pub use metal_rust_ffi::__private::values::IndexType;
pub use metal_rust_ffi::__private::values::IndirectCommandType;
pub use metal_rust_ffi::__private::values::IntersectionFunctionSignature;
pub use metal_rust_ffi::__private::values::LanguageVersion;
pub use metal_rust_ffi::__private::values::LibraryError;
pub use metal_rust_ffi::__private::values::LibraryOptimizationLevel;
pub use metal_rust_ffi::__private::values::LibraryType;
pub use metal_rust_ffi::__private::values::LoadAction;
pub use metal_rust_ffi::__private::values::LogLevel;
pub use metal_rust_ffi::__private::values::LogStateError;
pub use metal_rust_ffi::__private::values::MathFloatingPointFunctions;
pub use metal_rust_ffi::__private::values::MathMode;
pub use metal_rust_ffi::__private::values::MatrixLayout;
pub use metal_rust_ffi::__private::values::MotionBorderMode;
pub use metal_rust_ffi::__private::values::MultisampleDepthResolveFilter;
pub use metal_rust_ffi::__private::values::MultisampleStencilResolveFilter;
pub use metal_rust_ffi::__private::values::Mutability;
pub use metal_rust_ffi::__private::values::PatchType;
pub use metal_rust_ffi::__private::values::PipelineOption;
pub use metal_rust_ffi::__private::values::PrimitiveTopologyClass;
pub use metal_rust_ffi::__private::values::PurgeableState;
pub use metal_rust_ffi::__private::values::ReadWriteTextureTier;
pub use metal_rust_ffi::__private::values::RenderStages;
pub use metal_rust_ffi::__private::values::ResourceUsage;
pub use metal_rust_ffi::__private::values::SamplerAddressMode;
pub use metal_rust_ffi::__private::values::SamplerBorderColor;
pub use metal_rust_ffi::__private::values::SamplerMinMagFilter;
pub use metal_rust_ffi::__private::values::SamplerMipFilter;
pub use metal_rust_ffi::__private::values::SamplerReductionMode;
pub use metal_rust_ffi::__private::values::ShaderValidation;
pub use metal_rust_ffi::__private::values::SparsePageSize;
pub use metal_rust_ffi::__private::values::SparseTextureMappingMode;
pub use metal_rust_ffi::__private::values::SparseTextureRegionAlignmentMode;
pub use metal_rust_ffi::__private::values::Stages;
pub use metal_rust_ffi::__private::values::StencilOperation;
pub use metal_rust_ffi::__private::values::StepFunction;
pub use metal_rust_ffi::__private::values::StitchedLibraryOptions;
pub use metal_rust_ffi::__private::values::StoreAction;
pub use metal_rust_ffi::__private::values::StoreActionOptions;
pub use metal_rust_ffi::__private::values::TensorDataType;
pub use metal_rust_ffi::__private::values::TensorError;
pub use metal_rust_ffi::__private::values::TensorPlaneType;
pub use metal_rust_ffi::__private::values::TensorUsage;
pub use metal_rust_ffi::__private::values::TessellationControlPointIndexType;
pub use metal_rust_ffi::__private::values::TessellationFactorFormat;
pub use metal_rust_ffi::__private::values::TessellationFactorStepFunction;
pub use metal_rust_ffi::__private::values::TessellationPartitionMode;
pub use metal_rust_ffi::__private::values::TextureCompressionType;
pub use metal_rust_ffi::__private::values::TextureSparseTier;
pub use metal_rust_ffi::__private::values::TextureSwizzle;
pub use metal_rust_ffi::__private::values::TransformType;
pub use metal_rust_ffi::__private::values::TriangleFillMode;
pub use metal_rust_ffi::__private::values::VertexFormat;
pub use metal_rust_ffi::__private::values::VertexStepFunction;
pub use metal_rust_ffi::__private::values::VisibilityResultMode;
pub use metal_rust_ffi::__private::values::VisibilityResultType;
pub use metal_rust_ffi::__private::values::Winding;
pub type Coordinate2D = crate::metal::SamplePosition;
pub type GPUAddress = u64;
pub type Timestamp = u64;
#[derive(Clone)]
pub struct AccelerationStructure {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::AccelerationStructure,
}
impl AccelerationStructure {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructure,
) -> Self {
Self { inner }
}
pub fn size(&self) -> Result<usize, crate::Error> {
self.inner.size().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureBoundingBoxGeometryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureBoundingBoxGeometryDescriptor,
}
impl AccelerationStructureBoundingBoxGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureBoundingBoxGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AccelerationStructureBoundingBoxGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn bounding_box_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.bounding_box_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_bounding_box_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_bounding_box_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn bounding_box_count(&self) -> Result<usize, crate::Error> {
self.inner
.bounding_box_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_bounding_box_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_bounding_box_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn bounding_box_stride(&self) -> Result<usize, crate::Error> {
self.inner
.bounding_box_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_bounding_box_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_bounding_box_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn bounding_box_buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.bounding_box_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_bounding_box_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_bounding_box_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureCommandEncoder {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::AccelerationStructureCommandEncoder,
}
impl AccelerationStructureCommandEncoder {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureCommandEncoder,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct AccelerationStructureCurveGeometryDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::AccelerationStructureCurveGeometryDescriptor,
}
impl AccelerationStructureCurveGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureCurveGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AccelerationStructureCurveGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.control_point_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_control_point_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_count(&self) -> Result<usize, crate::Error> {
self.inner
.control_point_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_control_point_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_stride(&self) -> Result<usize, crate::Error> {
self.inner
.control_point_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_control_point_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.index_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_index_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_index_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn radius_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.radius_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_radius_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_radius_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn radius_stride(&self) -> Result<usize, crate::Error> {
self.inner.radius_stride().map_err(crate::Error::from_ffi)
}
pub fn set_radius_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_radius_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn segment_control_point_count(&self) -> Result<usize, crate::Error> {
self.inner
.segment_control_point_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_segment_control_point_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_segment_control_point_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn segment_count(&self) -> Result<usize, crate::Error> {
self.inner.segment_count().map_err(crate::Error::from_ffi)
}
pub fn set_segment_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_segment_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner
.control_point_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_control_point_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_basis(&self) -> Result<crate::metal::CurveBasis, crate::Error> {
self.inner.curve_basis().map_err(crate::Error::from_ffi)
}
pub fn set_curve_basis(&self, value: crate::metal::CurveBasis) -> Result<(), crate::Error> {
self.inner
.set_curve_basis(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_end_caps(&self) -> Result<crate::metal::CurveEndCaps, crate::Error> {
self.inner.curve_end_caps().map_err(crate::Error::from_ffi)
}
pub fn set_curve_end_caps(
&self,
value: crate::metal::CurveEndCaps,
) -> Result<(), crate::Error> {
self.inner
.set_curve_end_caps(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_type(&self) -> Result<crate::metal::CurveType, crate::Error> {
self.inner.curve_type().map_err(crate::Error::from_ffi)
}
pub fn set_curve_type(&self, value: crate::metal::CurveType) -> Result<(), crate::Error> {
self.inner
.set_curve_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_type(&self) -> Result<crate::metal::IndexType, crate::Error> {
self.inner.index_type().map_err(crate::Error::from_ffi)
}
pub fn set_index_type(&self, value: crate::metal::IndexType) -> Result<(), crate::Error> {
self.inner
.set_index_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn radius_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner.radius_format().map_err(crate::Error::from_ffi)
}
pub fn set_radius_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_radius_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.control_point_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_control_point_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn index_buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.index_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_index_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_index_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn radius_buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.radius_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_radius_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_radius_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::AccelerationStructureDescriptor,
}
impl AccelerationStructureDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AccelerationStructureDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn usage(&self) -> Result<crate::metal::AccelerationStructureUsage, crate::Error> {
self.inner.usage().map_err(crate::Error::from_ffi)
}
pub fn set_usage(
&self,
value: crate::metal::AccelerationStructureUsage,
) -> Result<(), crate::Error> {
self.inner.set_usage(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureGeometryDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::AccelerationStructureGeometryDescriptor,
}
impl AccelerationStructureGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AccelerationStructureGeometryDescriptor::new(
)
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn allow_duplicate_intersection_function_invocation(
&self,
) -> Result<bool, crate::Error> {
self.inner
.allow_duplicate_intersection_function_invocation()
.map_err(crate::Error::from_ffi)
}
pub fn intersection_function_table_offset(&self) -> Result<usize, crate::Error> {
self.inner
.intersection_function_table_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_intersection_function_table_offset(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_intersection_function_table_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn opaque(&self) -> Result<bool, crate::Error> {
self.inner.opaque().map_err(crate::Error::from_ffi)
}
pub fn primitive_data_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.primitive_data_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_primitive_data_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_primitive_data_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn primitive_data_element_size(&self) -> Result<usize, crate::Error> {
self.inner
.primitive_data_element_size()
.map_err(crate::Error::from_ffi)
}
pub fn set_primitive_data_element_size(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_primitive_data_element_size(value)
.map_err(crate::Error::from_ffi)
}
pub fn primitive_data_stride(&self) -> Result<usize, crate::Error> {
self.inner
.primitive_data_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_primitive_data_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_primitive_data_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn primitive_data_buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.primitive_data_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_primitive_data_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_primitive_data_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_allow_duplicate_intersection_function_invocation(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_allow_duplicate_intersection_function_invocation(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_opaque(&self, value: bool) -> Result<(), crate::Error> {
self.inner.set_opaque(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureMotionBoundingBoxGeometryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureMotionBoundingBoxGeometryDescriptor,
}
impl AccelerationStructureMotionBoundingBoxGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureMotionBoundingBoxGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AccelerationStructureMotionBoundingBoxGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn bounding_box_count(&self) -> Result<usize, crate::Error> {
self.inner
.bounding_box_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_bounding_box_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_bounding_box_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn bounding_box_stride(&self) -> Result<usize, crate::Error> {
self.inner
.bounding_box_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_bounding_box_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_bounding_box_stride(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureMotionCurveGeometryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureMotionCurveGeometryDescriptor,
}
impl AccelerationStructureMotionCurveGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureMotionCurveGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AccelerationStructureMotionCurveGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_count(&self) -> Result<usize, crate::Error> {
self.inner
.control_point_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_control_point_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_stride(&self) -> Result<usize, crate::Error> {
self.inner
.control_point_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_control_point_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.index_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_index_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_index_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn radius_stride(&self) -> Result<usize, crate::Error> {
self.inner.radius_stride().map_err(crate::Error::from_ffi)
}
pub fn set_radius_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_radius_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn segment_control_point_count(&self) -> Result<usize, crate::Error> {
self.inner
.segment_control_point_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_segment_control_point_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_segment_control_point_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn segment_count(&self) -> Result<usize, crate::Error> {
self.inner.segment_count().map_err(crate::Error::from_ffi)
}
pub fn set_segment_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_segment_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner
.control_point_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_control_point_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_basis(&self) -> Result<crate::metal::CurveBasis, crate::Error> {
self.inner.curve_basis().map_err(crate::Error::from_ffi)
}
pub fn set_curve_basis(&self, value: crate::metal::CurveBasis) -> Result<(), crate::Error> {
self.inner
.set_curve_basis(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_end_caps(&self) -> Result<crate::metal::CurveEndCaps, crate::Error> {
self.inner.curve_end_caps().map_err(crate::Error::from_ffi)
}
pub fn set_curve_end_caps(
&self,
value: crate::metal::CurveEndCaps,
) -> Result<(), crate::Error> {
self.inner
.set_curve_end_caps(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_type(&self) -> Result<crate::metal::CurveType, crate::Error> {
self.inner.curve_type().map_err(crate::Error::from_ffi)
}
pub fn set_curve_type(&self, value: crate::metal::CurveType) -> Result<(), crate::Error> {
self.inner
.set_curve_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_type(&self) -> Result<crate::metal::IndexType, crate::Error> {
self.inner.index_type().map_err(crate::Error::from_ffi)
}
pub fn set_index_type(&self, value: crate::metal::IndexType) -> Result<(), crate::Error> {
self.inner
.set_index_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn radius_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner.radius_format().map_err(crate::Error::from_ffi)
}
pub fn set_radius_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_radius_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.index_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_index_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_index_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureMotionTriangleGeometryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureMotionTriangleGeometryDescriptor,
}
impl AccelerationStructureMotionTriangleGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureMotionTriangleGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AccelerationStructureMotionTriangleGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn index_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.index_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_index_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_index_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn transformation_matrix_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.transformation_matrix_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_transformation_matrix_buffer_offset(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_transformation_matrix_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn triangle_count(&self) -> Result<usize, crate::Error> {
self.inner.triangle_count().map_err(crate::Error::from_ffi)
}
pub fn set_triangle_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_triangle_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn vertex_stride(&self) -> Result<usize, crate::Error> {
self.inner.vertex_stride().map_err(crate::Error::from_ffi)
}
pub fn set_vertex_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_vertex_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_type(&self) -> Result<crate::metal::IndexType, crate::Error> {
self.inner.index_type().map_err(crate::Error::from_ffi)
}
pub fn set_index_type(&self, value: crate::metal::IndexType) -> Result<(), crate::Error> {
self.inner
.set_index_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn transformation_matrix_layout(
&self,
) -> Result<crate::metal::MatrixLayout, crate::Error> {
self.inner
.transformation_matrix_layout()
.map_err(crate::Error::from_ffi)
}
pub fn set_transformation_matrix_layout(
&self,
value: crate::metal::MatrixLayout,
) -> Result<(), crate::Error> {
self.inner
.set_transformation_matrix_layout(value)
.map_err(crate::Error::from_ffi)
}
pub fn vertex_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner.vertex_format().map_err(crate::Error::from_ffi)
}
pub fn set_vertex_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_vertex_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.index_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_index_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_index_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn transformation_matrix_buffer(
&self,
) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.transformation_matrix_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_transformation_matrix_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_transformation_matrix_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructurePassDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::AccelerationStructurePassDescriptor,
}
impl AccelerationStructurePassDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructurePassDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AccelerationStructurePassDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn sample_buffer_attachments(
&self,
) -> Result<
Option<crate::metal::AccelerationStructurePassSampleBufferAttachmentDescriptorArray>,
crate::Error,
> {
self.inner.sample_buffer_attachments()
.map(|value| value.map(crate::metal::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructurePassSampleBufferAttachmentDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::AccelerationStructurePassSampleBufferAttachmentDescriptor,
}
impl AccelerationStructurePassSampleBufferAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructurePassSampleBufferAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AccelerationStructurePassSampleBufferAttachmentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn end_of_encoder_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.end_of_encoder_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_end_of_encoder_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_end_of_encoder_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn start_of_encoder_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.start_of_encoder_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_start_of_encoder_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_start_of_encoder_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn sample_buffer(
&self,
) -> Result<Option<crate::metal::CounterSampleBuffer>, crate::Error> {
self.inner
.sample_buffer()
.map(|value| value.map(crate::metal::CounterSampleBuffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_sample_buffer(
&self,
value: Option<&crate::metal::CounterSampleBuffer>,
) -> Result<(), crate::Error> {
self.inner
.set_sample_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructurePassSampleBufferAttachmentDescriptorArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::AccelerationStructurePassSampleBufferAttachmentDescriptorArray,
}
impl AccelerationStructurePassSampleBufferAttachmentDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructurePassSampleBufferAttachmentDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureTriangleGeometryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureTriangleGeometryDescriptor,
}
impl AccelerationStructureTriangleGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AccelerationStructureTriangleGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AccelerationStructureTriangleGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn index_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.index_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_index_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_index_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn transformation_matrix_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.transformation_matrix_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_transformation_matrix_buffer_offset(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_transformation_matrix_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn triangle_count(&self) -> Result<usize, crate::Error> {
self.inner.triangle_count().map_err(crate::Error::from_ffi)
}
pub fn set_triangle_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_triangle_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn vertex_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.vertex_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_vertex_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_vertex_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn vertex_stride(&self) -> Result<usize, crate::Error> {
self.inner.vertex_stride().map_err(crate::Error::from_ffi)
}
pub fn set_vertex_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_vertex_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_type(&self) -> Result<crate::metal::IndexType, crate::Error> {
self.inner.index_type().map_err(crate::Error::from_ffi)
}
pub fn set_index_type(&self, value: crate::metal::IndexType) -> Result<(), crate::Error> {
self.inner
.set_index_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn transformation_matrix_layout(
&self,
) -> Result<crate::metal::MatrixLayout, crate::Error> {
self.inner
.transformation_matrix_layout()
.map_err(crate::Error::from_ffi)
}
pub fn set_transformation_matrix_layout(
&self,
value: crate::metal::MatrixLayout,
) -> Result<(), crate::Error> {
self.inner
.set_transformation_matrix_layout(value)
.map_err(crate::Error::from_ffi)
}
pub fn vertex_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner.vertex_format().map_err(crate::Error::from_ffi)
}
pub fn set_vertex_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_vertex_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.index_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_index_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_index_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn transformation_matrix_buffer(
&self,
) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.transformation_matrix_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_transformation_matrix_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_transformation_matrix_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn vertex_buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.vertex_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_vertex_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_vertex_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Allocation {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Allocation,
}
impl Allocation {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Allocation,
) -> Self {
Self { inner }
}
pub fn allocated_size(&self) -> Result<usize, crate::Error> {
self.inner.allocated_size().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Architecture {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Architecture,
}
impl Architecture {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Architecture,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::Architecture::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Argument {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Argument,
}
impl Argument {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Argument,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::Argument::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn array_length(&self) -> Result<usize, crate::Error> {
self.inner.array_length().map_err(crate::Error::from_ffi)
}
pub fn buffer_alignment(&self) -> Result<usize, crate::Error> {
self.inner
.buffer_alignment()
.map_err(crate::Error::from_ffi)
}
pub fn buffer_data_size(&self) -> Result<usize, crate::Error> {
self.inner
.buffer_data_size()
.map_err(crate::Error::from_ffi)
}
pub fn index(&self) -> Result<usize, crate::Error> {
self.inner.index().map_err(crate::Error::from_ffi)
}
pub fn is_active(&self) -> Result<bool, crate::Error> {
self.inner.is_active().map_err(crate::Error::from_ffi)
}
pub fn is_depth_texture(&self) -> Result<bool, crate::Error> {
self.inner
.is_depth_texture()
.map_err(crate::Error::from_ffi)
}
pub fn threadgroup_memory_alignment(&self) -> Result<usize, crate::Error> {
self.inner
.threadgroup_memory_alignment()
.map_err(crate::Error::from_ffi)
}
pub fn threadgroup_memory_data_size(&self) -> Result<usize, crate::Error> {
self.inner
.threadgroup_memory_data_size()
.map_err(crate::Error::from_ffi)
}
pub fn access(&self) -> Result<crate::metal::BindingAccess, crate::Error> {
self.inner.access().map_err(crate::Error::from_ffi)
}
pub fn buffer_data_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner
.buffer_data_type()
.map_err(crate::Error::from_ffi)
}
pub fn texture_data_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner
.texture_data_type()
.map_err(crate::Error::from_ffi)
}
pub fn texture_type(&self) -> Result<crate::metal::TextureType, crate::Error> {
self.inner.texture_type().map_err(crate::Error::from_ffi)
}
pub fn r#type(&self) -> Result<crate::metal::ArgumentType, crate::Error> {
self.inner.r#type().map_err(crate::Error::from_ffi)
}
pub fn buffer_pointer_type(
&self,
) -> Result<Option<crate::metal::PointerType>, crate::Error> {
self.inner
.buffer_pointer_type()
.map(|value| value.map(crate::metal::PointerType::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn buffer_struct_type(&self) -> Result<Option<crate::metal::StructType>, crate::Error> {
self.inner
.buffer_struct_type()
.map(|value| value.map(crate::metal::StructType::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ArgumentDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ArgumentDescriptor,
}
impl ArgumentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ArgumentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::ArgumentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn array_length(&self) -> Result<usize, crate::Error> {
self.inner.array_length().map_err(crate::Error::from_ffi)
}
pub fn set_array_length(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_array_length(value)
.map_err(crate::Error::from_ffi)
}
pub fn constant_block_alignment(&self) -> Result<usize, crate::Error> {
self.inner
.constant_block_alignment()
.map_err(crate::Error::from_ffi)
}
pub fn set_constant_block_alignment(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_constant_block_alignment(value)
.map_err(crate::Error::from_ffi)
}
pub fn index(&self) -> Result<usize, crate::Error> {
self.inner.index().map_err(crate::Error::from_ffi)
}
pub fn set_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner.set_index(value).map_err(crate::Error::from_ffi)
}
pub fn access(&self) -> Result<crate::metal::BindingAccess, crate::Error> {
self.inner.access().map_err(crate::Error::from_ffi)
}
pub fn set_access(&self, value: crate::metal::BindingAccess) -> Result<(), crate::Error> {
self.inner.set_access(value).map_err(crate::Error::from_ffi)
}
pub fn data_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner.data_type().map_err(crate::Error::from_ffi)
}
pub fn set_data_type(&self, value: crate::metal::DataType) -> Result<(), crate::Error> {
self.inner
.set_data_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn texture_type(&self) -> Result<crate::metal::TextureType, crate::Error> {
self.inner.texture_type().map_err(crate::Error::from_ffi)
}
pub fn set_texture_type(
&self,
value: crate::metal::TextureType,
) -> Result<(), crate::Error> {
self.inner
.set_texture_type(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ArgumentEncoder {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ArgumentEncoder,
}
impl ArgumentEncoder {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ArgumentEncoder,
) -> Self {
Self { inner }
}
pub fn alignment(&self) -> Result<usize, crate::Error> {
self.inner.alignment().map_err(crate::Error::from_ffi)
}
pub fn encoded_length(&self) -> Result<usize, crate::Error> {
self.inner.encoded_length().map_err(crate::Error::from_ffi)
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ArrayType {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ArrayType,
}
impl ArrayType {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ArrayType,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::ArrayType::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn argument_index_stride(&self) -> Result<usize, crate::Error> {
self.inner
.argument_index_stride()
.map_err(crate::Error::from_ffi)
}
pub fn array_length(&self) -> Result<usize, crate::Error> {
self.inner.array_length().map_err(crate::Error::from_ffi)
}
pub fn stride(&self) -> Result<usize, crate::Error> {
self.inner.stride().map_err(crate::Error::from_ffi)
}
pub fn element_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner.element_type().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Attribute {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Attribute,
}
impl Attribute {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Attribute,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::Attribute::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn attribute_index(&self) -> Result<usize, crate::Error> {
self.inner.attribute_index().map_err(crate::Error::from_ffi)
}
pub fn is_active(&self) -> Result<bool, crate::Error> {
self.inner.is_active().map_err(crate::Error::from_ffi)
}
pub fn is_patch_control_point_data(&self) -> Result<bool, crate::Error> {
self.inner
.is_patch_control_point_data()
.map_err(crate::Error::from_ffi)
}
pub fn is_patch_data(&self) -> Result<bool, crate::Error> {
self.inner.is_patch_data().map_err(crate::Error::from_ffi)
}
pub fn attribute_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner.attribute_type().map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AttributeDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::AttributeDescriptor,
}
impl AttributeDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AttributeDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AttributeDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn buffer_index(&self) -> Result<usize, crate::Error> {
self.inner.buffer_index().map_err(crate::Error::from_ffi)
}
pub fn set_buffer_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_buffer_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn offset(&self) -> Result<usize, crate::Error> {
self.inner.offset().map_err(crate::Error::from_ffi)
}
pub fn set_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner.set_offset(value).map_err(crate::Error::from_ffi)
}
pub fn format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner.format().map_err(crate::Error::from_ffi)
}
pub fn set_format(&self, value: crate::metal::AttributeFormat) -> Result<(), crate::Error> {
self.inner.set_format(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AttributeDescriptorArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::AttributeDescriptorArray,
}
impl AttributeDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::AttributeDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::AttributeDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct BinaryArchive {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::BinaryArchive,
}
impl BinaryArchive {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::BinaryArchive,
) -> Self {
Self { inner }
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct BinaryArchiveDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::BinaryArchiveDescriptor,
}
impl BinaryArchiveDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::BinaryArchiveDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::BinaryArchiveDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Binding {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Binding,
}
impl Binding {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Binding,
) -> Self {
Self { inner }
}
pub fn index(&self) -> Result<usize, crate::Error> {
self.inner.index().map_err(crate::Error::from_ffi)
}
pub fn is_argument(&self) -> Result<bool, crate::Error> {
self.inner.is_argument().map_err(crate::Error::from_ffi)
}
pub fn is_used(&self) -> Result<bool, crate::Error> {
self.inner.is_used().map_err(crate::Error::from_ffi)
}
pub fn access(&self) -> Result<crate::metal::BindingAccess, crate::Error> {
self.inner.access().map_err(crate::Error::from_ffi)
}
pub fn r#type(&self) -> Result<crate::metal::BindingType, crate::Error> {
self.inner.r#type().map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct BlitPassDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::BlitPassDescriptor,
}
impl BlitPassDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::BlitPassDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::BlitPassDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn sample_buffer_attachments(
&self,
) -> Result<Option<crate::metal::BlitPassSampleBufferAttachmentDescriptorArray>, crate::Error>
{
self.inner
.sample_buffer_attachments()
.map(|value| {
value.map(crate::metal::BlitPassSampleBufferAttachmentDescriptorArray::from_ffi)
})
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct BlitPassSampleBufferAttachmentDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::BlitPassSampleBufferAttachmentDescriptor,
}
impl BlitPassSampleBufferAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::BlitPassSampleBufferAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::BlitPassSampleBufferAttachmentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn end_of_encoder_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.end_of_encoder_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_end_of_encoder_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_end_of_encoder_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn start_of_encoder_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.start_of_encoder_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_start_of_encoder_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_start_of_encoder_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn sample_buffer(
&self,
) -> Result<Option<crate::metal::CounterSampleBuffer>, crate::Error> {
self.inner
.sample_buffer()
.map(|value| value.map(crate::metal::CounterSampleBuffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_sample_buffer(
&self,
value: Option<&crate::metal::CounterSampleBuffer>,
) -> Result<(), crate::Error> {
self.inner
.set_sample_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct BlitPassSampleBufferAttachmentDescriptorArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::BlitPassSampleBufferAttachmentDescriptorArray,
}
impl BlitPassSampleBufferAttachmentDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::BlitPassSampleBufferAttachmentDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::BlitPassSampleBufferAttachmentDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct BufferBinding {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::BufferBinding,
}
impl BufferBinding {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::BufferBinding,
) -> Self {
Self { inner }
}
pub fn buffer_alignment(&self) -> Result<usize, crate::Error> {
self.inner
.buffer_alignment()
.map_err(crate::Error::from_ffi)
}
pub fn buffer_data_size(&self) -> Result<usize, crate::Error> {
self.inner
.buffer_data_size()
.map_err(crate::Error::from_ffi)
}
pub fn buffer_data_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner
.buffer_data_type()
.map_err(crate::Error::from_ffi)
}
pub fn buffer_pointer_type(
&self,
) -> Result<Option<crate::metal::PointerType>, crate::Error> {
self.inner
.buffer_pointer_type()
.map(|value| value.map(crate::metal::PointerType::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn buffer_struct_type(&self) -> Result<Option<crate::metal::StructType>, crate::Error> {
self.inner
.buffer_struct_type()
.map(|value| value.map(crate::metal::StructType::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct BufferLayoutDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::BufferLayoutDescriptor,
}
impl BufferLayoutDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::BufferLayoutDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::BufferLayoutDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn step_rate(&self) -> Result<usize, crate::Error> {
self.inner.step_rate().map_err(crate::Error::from_ffi)
}
pub fn set_step_rate(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_step_rate(value)
.map_err(crate::Error::from_ffi)
}
pub fn stride(&self) -> Result<usize, crate::Error> {
self.inner.stride().map_err(crate::Error::from_ffi)
}
pub fn set_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner.set_stride(value).map_err(crate::Error::from_ffi)
}
pub fn step_function(&self) -> Result<crate::metal::StepFunction, crate::Error> {
self.inner.step_function().map_err(crate::Error::from_ffi)
}
pub fn set_step_function(
&self,
value: crate::metal::StepFunction,
) -> Result<(), crate::Error> {
self.inner
.set_step_function(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct BufferLayoutDescriptorArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::BufferLayoutDescriptorArray,
}
impl BufferLayoutDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::BufferLayoutDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::BufferLayoutDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CaptureDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::CaptureDescriptor,
}
impl CaptureDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::CaptureDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::CaptureDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn destination(&self) -> Result<crate::metal::CaptureDestination, crate::Error> {
self.inner.destination().map_err(crate::Error::from_ffi)
}
pub fn set_destination(
&self,
value: crate::metal::CaptureDestination,
) -> Result<(), crate::Error> {
self.inner
.set_destination(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CaptureScope {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::CaptureScope,
}
impl CaptureScope {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::CaptureScope,
) -> Self {
Self { inner }
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CommandBufferDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::CommandBufferDescriptor,
}
impl CommandBufferDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::CommandBufferDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::CommandBufferDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn retained_references(&self) -> Result<bool, crate::Error> {
self.inner
.retained_references()
.map_err(crate::Error::from_ffi)
}
pub fn error_options(
&self,
) -> Result<crate::metal::CommandBufferErrorOption, crate::Error> {
self.inner.error_options().map_err(crate::Error::from_ffi)
}
pub fn set_error_options(
&self,
value: crate::metal::CommandBufferErrorOption,
) -> Result<(), crate::Error> {
self.inner
.set_error_options(value)
.map_err(crate::Error::from_ffi)
}
pub fn log_state(&self) -> Result<Option<crate::metal::LogState>, crate::Error> {
self.inner
.log_state()
.map(|value| value.map(crate::metal::LogState::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_log_state(
&self,
value: Option<&crate::metal::LogState>,
) -> Result<(), crate::Error> {
self.inner
.set_log_state(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_retained_references(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_retained_references(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CommandBufferEncoderInfo {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::CommandBufferEncoderInfo,
}
impl CommandBufferEncoderInfo {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::CommandBufferEncoderInfo,
) -> Self {
Self { inner }
}
pub fn error_state(&self) -> Result<crate::metal::CommandEncoderErrorState, crate::Error> {
self.inner.error_state().map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CommandEncoder {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::CommandEncoder,
}
impl CommandEncoder {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::CommandEncoder,
) -> Self {
Self { inner }
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CommandQueueDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::CommandQueueDescriptor,
}
impl CommandQueueDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::CommandQueueDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::CommandQueueDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn max_command_buffer_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_command_buffer_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_command_buffer_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_command_buffer_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn log_state(&self) -> Result<Option<crate::metal::LogState>, crate::Error> {
self.inner
.log_state()
.map(|value| value.map(crate::metal::LogState::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_log_state(
&self,
value: Option<&crate::metal::LogState>,
) -> Result<(), crate::Error> {
self.inner
.set_log_state(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ComputePassSampleBufferAttachmentDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::ComputePassSampleBufferAttachmentDescriptor,
}
impl ComputePassSampleBufferAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ComputePassSampleBufferAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::ComputePassSampleBufferAttachmentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn end_of_encoder_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.end_of_encoder_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_end_of_encoder_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_end_of_encoder_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn start_of_encoder_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.start_of_encoder_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_start_of_encoder_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_start_of_encoder_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn sample_buffer(
&self,
) -> Result<Option<crate::metal::CounterSampleBuffer>, crate::Error> {
self.inner
.sample_buffer()
.map(|value| value.map(crate::metal::CounterSampleBuffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_sample_buffer(
&self,
value: Option<&crate::metal::CounterSampleBuffer>,
) -> Result<(), crate::Error> {
self.inner
.set_sample_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ComputePassSampleBufferAttachmentDescriptorArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ComputePassSampleBufferAttachmentDescriptorArray,
}
impl ComputePassSampleBufferAttachmentDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ComputePassSampleBufferAttachmentDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::ComputePassSampleBufferAttachmentDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ComputePipelineDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ComputePipelineDescriptor,
}
impl ComputePipelineDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ComputePipelineDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::ComputePipelineDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn max_call_stack_depth(&self) -> Result<usize, crate::Error> {
self.inner
.max_call_stack_depth()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_call_stack_depth(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_call_stack_depth(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_total_threads_per_threadgroup(&self) -> Result<usize, crate::Error> {
self.inner
.max_total_threads_per_threadgroup()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_total_threads_per_threadgroup(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_total_threads_per_threadgroup(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_adding_binary_functions(&self) -> Result<bool, crate::Error> {
self.inner
.support_adding_binary_functions()
.map_err(crate::Error::from_ffi)
}
pub fn support_indirect_command_buffers(&self) -> Result<bool, crate::Error> {
self.inner
.support_indirect_command_buffers()
.map_err(crate::Error::from_ffi)
}
pub fn thread_group_size_is_multiple_of_thread_execution_width(
&self,
) -> Result<bool, crate::Error> {
self.inner
.thread_group_size_is_multiple_of_thread_execution_width()
.map_err(crate::Error::from_ffi)
}
pub fn shader_validation(&self) -> Result<crate::metal::ShaderValidation, crate::Error> {
self.inner
.shader_validation()
.map_err(crate::Error::from_ffi)
}
pub fn set_shader_validation(
&self,
value: crate::metal::ShaderValidation,
) -> Result<(), crate::Error> {
self.inner
.set_shader_validation(value)
.map_err(crate::Error::from_ffi)
}
pub fn buffers(
&self,
) -> Result<Option<crate::metal::PipelineBufferDescriptorArray>, crate::Error> {
self.inner
.buffers()
.map(|value| value.map(crate::metal::PipelineBufferDescriptorArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn compute_function(&self) -> Result<Option<crate::metal::Function>, crate::Error> {
self.inner
.compute_function()
.map(|value| value.map(crate::metal::Function::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_compute_function(
&self,
value: Option<&crate::metal::Function>,
) -> Result<(), crate::Error> {
self.inner
.set_compute_function(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn linked_functions(
&self,
) -> Result<Option<crate::metal::LinkedFunctions>, crate::Error> {
self.inner
.linked_functions()
.map(|value| value.map(crate::metal::LinkedFunctions::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_linked_functions(
&self,
value: Option<&crate::metal::LinkedFunctions>,
) -> Result<(), crate::Error> {
self.inner
.set_linked_functions(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn stage_input_descriptor(
&self,
) -> Result<Option<crate::metal::StageInputOutputDescriptor>, crate::Error> {
self.inner
.stage_input_descriptor()
.map(|value| value.map(crate::metal::StageInputOutputDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_stage_input_descriptor(
&self,
value: Option<&crate::metal::StageInputOutputDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_stage_input_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_support_adding_binary_functions(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_adding_binary_functions(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_indirect_command_buffers(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_support_indirect_command_buffers(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_thread_group_size_is_multiple_of_thread_execution_width(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_thread_group_size_is_multiple_of_thread_execution_width(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ComputePipelineReflection {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ComputePipelineReflection,
}
impl ComputePipelineReflection {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ComputePipelineReflection,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::ComputePipelineReflection::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Counter {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Counter,
}
impl Counter {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Counter,
) -> Self {
Self { inner }
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CounterSampleBuffer {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::CounterSampleBuffer,
}
impl CounterSampleBuffer {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::CounterSampleBuffer,
) -> Self {
Self { inner }
}
pub fn sample_count(&self) -> Result<usize, crate::Error> {
self.inner.sample_count().map_err(crate::Error::from_ffi)
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CounterSampleBufferDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::CounterSampleBufferDescriptor,
}
impl CounterSampleBufferDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::CounterSampleBufferDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::CounterSampleBufferDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn sample_count(&self) -> Result<usize, crate::Error> {
self.inner.sample_count().map_err(crate::Error::from_ffi)
}
pub fn set_sample_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_sample_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn storage_mode(&self) -> Result<crate::metal::StorageMode, crate::Error> {
self.inner.storage_mode().map_err(crate::Error::from_ffi)
}
pub fn set_storage_mode(
&self,
value: crate::metal::StorageMode,
) -> Result<(), crate::Error> {
self.inner
.set_storage_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn counter_set(&self) -> Result<Option<crate::metal::CounterSet>, crate::Error> {
self.inner
.counter_set()
.map(|value| value.map(crate::metal::CounterSet::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_counter_set(
&self,
value: Option<&crate::metal::CounterSet>,
) -> Result<(), crate::Error> {
self.inner
.set_counter_set(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CounterSet {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::CounterSet,
}
impl CounterSet {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::CounterSet,
) -> Self {
Self { inner }
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct DepthStencilDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::DepthStencilDescriptor,
}
impl DepthStencilDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::DepthStencilDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::DepthStencilDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn is_depth_write_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_depth_write_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn depth_compare_function(
&self,
) -> Result<crate::metal::CompareFunction, crate::Error> {
self.inner
.depth_compare_function()
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_compare_function(
&self,
value: crate::metal::CompareFunction,
) -> Result<(), crate::Error> {
self.inner
.set_depth_compare_function(value)
.map_err(crate::Error::from_ffi)
}
pub fn back_face_stencil(
&self,
) -> Result<Option<crate::metal::StencilDescriptor>, crate::Error> {
self.inner
.back_face_stencil()
.map(|value| value.map(crate::metal::StencilDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_back_face_stencil(
&self,
value: Option<&crate::metal::StencilDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_back_face_stencil(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn front_face_stencil(
&self,
) -> Result<Option<crate::metal::StencilDescriptor>, crate::Error> {
self.inner
.front_face_stencil()
.map(|value| value.map(crate::metal::StencilDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_front_face_stencil(
&self,
value: Option<&crate::metal::StencilDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_front_face_stencil(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn set_depth_write_enabled(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_depth_write_enabled(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct DepthStencilState {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::DepthStencilState,
}
impl DepthStencilState {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::DepthStencilState,
) -> Self {
Self { inner }
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Drawable {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Drawable,
}
impl Drawable {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Drawable,
) -> Self {
Self { inner }
}
pub fn drawable_id(&self) -> Result<usize, crate::Error> {
self.inner.drawable_id().map_err(crate::Error::from_ffi)
}
pub fn presented_time(&self) -> Result<f64, crate::Error> {
self.inner.presented_time().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct DynamicLibrary {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::DynamicLibrary,
}
impl DynamicLibrary {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::DynamicLibrary,
) -> Self {
Self { inner }
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn install_name(&self) -> Result<Option<String>, crate::Error> {
self.inner.install_name().map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Event {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Event,
}
impl Event {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Event,
) -> Self {
Self { inner }
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Fence {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Fence,
}
impl Fence {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Fence,
) -> Self {
Self { inner }
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionConstant {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionConstant,
}
impl FunctionConstant {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionConstant,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::FunctionConstant::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn index(&self) -> Result<usize, crate::Error> {
self.inner.index().map_err(crate::Error::from_ffi)
}
pub fn required(&self) -> Result<bool, crate::Error> {
self.inner.required().map_err(crate::Error::from_ffi)
}
pub fn r#type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner.r#type().map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionConstantValues {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionConstantValues,
}
impl FunctionConstantValues {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionConstantValues,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::FunctionConstantValues::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionDescriptor,
}
impl FunctionDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::FunctionDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn options(&self) -> Result<crate::metal::FunctionOptions, crate::Error> {
self.inner.options().map_err(crate::Error::from_ffi)
}
pub fn set_options(
&self,
value: crate::metal::FunctionOptions,
) -> Result<(), crate::Error> {
self.inner
.set_options(value)
.map_err(crate::Error::from_ffi)
}
pub fn constant_values(
&self,
) -> Result<Option<crate::metal::FunctionConstantValues>, crate::Error> {
self.inner
.constant_values()
.map(|value| value.map(crate::metal::FunctionConstantValues::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_constant_values(
&self,
value: Option<&crate::metal::FunctionConstantValues>,
) -> Result<(), crate::Error> {
self.inner
.set_constant_values(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
pub fn set_name(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_name(value).map_err(crate::Error::from_ffi)
}
pub fn specialized_name(&self) -> Result<Option<String>, crate::Error> {
self.inner
.specialized_name()
.map_err(crate::Error::from_ffi)
}
pub fn set_specialized_name(&self, value: &str) -> Result<(), crate::Error> {
self.inner
.set_specialized_name(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionHandle {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionHandle,
}
impl FunctionHandle {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionHandle,
) -> Self {
Self { inner }
}
pub fn function_type(&self) -> Result<crate::metal::FunctionType, crate::Error> {
self.inner.function_type().map_err(crate::Error::from_ffi)
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionLog {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionLog,
}
impl FunctionLog {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionLog,
) -> Self {
Self { inner }
}
pub fn r#type(&self) -> Result<crate::metal::FunctionLogType, crate::Error> {
self.inner.r#type().map_err(crate::Error::from_ffi)
}
pub fn debug_location(
&self,
) -> Result<Option<crate::metal::FunctionLogDebugLocation>, crate::Error> {
self.inner
.debug_location()
.map(|value| value.map(crate::metal::FunctionLogDebugLocation::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn encoder_label(&self) -> Result<Option<String>, crate::Error> {
self.inner.encoder_label().map_err(crate::Error::from_ffi)
}
pub fn function(&self) -> Result<Option<crate::metal::Function>, crate::Error> {
self.inner
.function()
.map(|value| value.map(crate::metal::Function::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionLogDebugLocation {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionLogDebugLocation,
}
impl FunctionLogDebugLocation {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionLogDebugLocation,
) -> Self {
Self { inner }
}
pub fn column(&self) -> Result<usize, crate::Error> {
self.inner.column().map_err(crate::Error::from_ffi)
}
pub fn line(&self) -> Result<usize, crate::Error> {
self.inner.line().map_err(crate::Error::from_ffi)
}
pub fn function_name(&self) -> Result<Option<String>, crate::Error> {
self.inner.function_name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionReflection {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionReflection,
}
impl FunctionReflection {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionReflection,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::FunctionReflection::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn user_annotation(&self) -> Result<Option<String>, crate::Error> {
self.inner.user_annotation().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionStitchingAttribute {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionStitchingAttribute,
}
impl FunctionStitchingAttribute {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionStitchingAttribute,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct FunctionStitchingAttributeAlwaysInline {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::FunctionStitchingAttributeAlwaysInline,
}
impl FunctionStitchingAttributeAlwaysInline {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionStitchingAttributeAlwaysInline,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::FunctionStitchingAttributeAlwaysInline::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionStitchingFunctionNode {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionStitchingFunctionNode,
}
impl FunctionStitchingFunctionNode {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionStitchingFunctionNode,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::FunctionStitchingFunctionNode::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
pub fn set_name(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_name(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionStitchingGraph {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionStitchingGraph,
}
impl FunctionStitchingGraph {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionStitchingGraph,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::FunctionStitchingGraph::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn function_name(&self) -> Result<Option<String>, crate::Error> {
self.inner.function_name().map_err(crate::Error::from_ffi)
}
pub fn set_function_name(&self, value: &str) -> Result<(), crate::Error> {
self.inner
.set_function_name(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_node(
&self,
) -> Result<Option<crate::metal::FunctionStitchingFunctionNode>, crate::Error> {
self.inner
.output_node()
.map(|value| value.map(crate::metal::FunctionStitchingFunctionNode::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_output_node(
&self,
value: Option<&crate::metal::FunctionStitchingFunctionNode>,
) -> Result<(), crate::Error> {
self.inner
.set_output_node(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionStitchingInputNode {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionStitchingInputNode,
}
impl FunctionStitchingInputNode {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionStitchingInputNode,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::FunctionStitchingInputNode::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn argument_index(&self) -> Result<usize, crate::Error> {
self.inner.argument_index().map_err(crate::Error::from_ffi)
}
pub fn set_argument_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_argument_index(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionStitchingNode {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::FunctionStitchingNode,
}
impl FunctionStitchingNode {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::FunctionStitchingNode,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct Heap {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Heap,
}
impl Heap {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Heap,
) -> Self {
Self { inner }
}
pub fn current_allocated_size(&self) -> Result<usize, crate::Error> {
self.inner
.current_allocated_size()
.map_err(crate::Error::from_ffi)
}
pub fn size(&self) -> Result<usize, crate::Error> {
self.inner.size().map_err(crate::Error::from_ffi)
}
pub fn used_size(&self) -> Result<usize, crate::Error> {
self.inner.used_size().map_err(crate::Error::from_ffi)
}
pub fn cpu_cache_mode(&self) -> Result<crate::metal::CPUCacheMode, crate::Error> {
self.inner.cpu_cache_mode().map_err(crate::Error::from_ffi)
}
pub fn hazard_tracking_mode(
&self,
) -> Result<crate::metal::HazardTrackingMode, crate::Error> {
self.inner
.hazard_tracking_mode()
.map_err(crate::Error::from_ffi)
}
pub fn resource_options(&self) -> Result<crate::metal::ResourceOptions, crate::Error> {
self.inner
.resource_options()
.map_err(crate::Error::from_ffi)
}
pub fn storage_mode(&self) -> Result<crate::metal::StorageMode, crate::Error> {
self.inner.storage_mode().map_err(crate::Error::from_ffi)
}
pub fn r#type(&self) -> Result<crate::metal::HeapType, crate::Error> {
self.inner.r#type().map_err(crate::Error::from_ffi)
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct HeapDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::HeapDescriptor,
}
impl HeapDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::HeapDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::HeapDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn size(&self) -> Result<usize, crate::Error> {
self.inner.size().map_err(crate::Error::from_ffi)
}
pub fn set_size(&self, value: usize) -> Result<(), crate::Error> {
self.inner.set_size(value).map_err(crate::Error::from_ffi)
}
pub fn cpu_cache_mode(&self) -> Result<crate::metal::CPUCacheMode, crate::Error> {
self.inner.cpu_cache_mode().map_err(crate::Error::from_ffi)
}
pub fn set_cpu_cache_mode(
&self,
value: crate::metal::CPUCacheMode,
) -> Result<(), crate::Error> {
self.inner
.set_cpu_cache_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn hazard_tracking_mode(
&self,
) -> Result<crate::metal::HazardTrackingMode, crate::Error> {
self.inner
.hazard_tracking_mode()
.map_err(crate::Error::from_ffi)
}
pub fn set_hazard_tracking_mode(
&self,
value: crate::metal::HazardTrackingMode,
) -> Result<(), crate::Error> {
self.inner
.set_hazard_tracking_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_compatible_placement_sparse_page_size(
&self,
) -> Result<crate::metal::SparsePageSize, crate::Error> {
self.inner
.max_compatible_placement_sparse_page_size()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_compatible_placement_sparse_page_size(
&self,
value: crate::metal::SparsePageSize,
) -> Result<(), crate::Error> {
self.inner
.set_max_compatible_placement_sparse_page_size(value)
.map_err(crate::Error::from_ffi)
}
pub fn resource_options(&self) -> Result<crate::metal::ResourceOptions, crate::Error> {
self.inner
.resource_options()
.map_err(crate::Error::from_ffi)
}
pub fn set_resource_options(
&self,
value: crate::metal::ResourceOptions,
) -> Result<(), crate::Error> {
self.inner
.set_resource_options(value)
.map_err(crate::Error::from_ffi)
}
pub fn sparse_page_size(&self) -> Result<crate::metal::SparsePageSize, crate::Error> {
self.inner
.sparse_page_size()
.map_err(crate::Error::from_ffi)
}
pub fn set_sparse_page_size(
&self,
value: crate::metal::SparsePageSize,
) -> Result<(), crate::Error> {
self.inner
.set_sparse_page_size(value)
.map_err(crate::Error::from_ffi)
}
pub fn storage_mode(&self) -> Result<crate::metal::StorageMode, crate::Error> {
self.inner.storage_mode().map_err(crate::Error::from_ffi)
}
pub fn set_storage_mode(
&self,
value: crate::metal::StorageMode,
) -> Result<(), crate::Error> {
self.inner
.set_storage_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn r#type(&self) -> Result<crate::metal::HeapType, crate::Error> {
self.inner.r#type().map_err(crate::Error::from_ffi)
}
pub fn set_type(&self, value: crate::metal::HeapType) -> Result<(), crate::Error> {
self.inner.set_type(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IOCommandBuffer {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IOCommandBuffer,
}
impl IOCommandBuffer {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IOCommandBuffer,
) -> Self {
Self { inner }
}
pub fn status(&self) -> Result<crate::metal::IOStatus, crate::Error> {
self.inner.status().map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IOCommandQueue {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IOCommandQueue,
}
impl IOCommandQueue {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IOCommandQueue,
) -> Self {
Self { inner }
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IOCommandQueueDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IOCommandQueueDescriptor,
}
impl IOCommandQueueDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IOCommandQueueDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::IOCommandQueueDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn max_command_buffer_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_command_buffer_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_command_buffer_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_command_buffer_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_commands_in_flight(&self) -> Result<usize, crate::Error> {
self.inner
.max_commands_in_flight()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_commands_in_flight(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_commands_in_flight(value)
.map_err(crate::Error::from_ffi)
}
pub fn priority(&self) -> Result<crate::metal::IOPriority, crate::Error> {
self.inner.priority().map_err(crate::Error::from_ffi)
}
pub fn set_priority(&self, value: crate::metal::IOPriority) -> Result<(), crate::Error> {
self.inner
.set_priority(value)
.map_err(crate::Error::from_ffi)
}
pub fn r#type(&self) -> Result<crate::metal::IOCommandQueueType, crate::Error> {
self.inner.r#type().map_err(crate::Error::from_ffi)
}
pub fn set_type(
&self,
value: crate::metal::IOCommandQueueType,
) -> Result<(), crate::Error> {
self.inner.set_type(value).map_err(crate::Error::from_ffi)
}
pub fn scratch_buffer_allocator(
&self,
) -> Result<Option<crate::metal::IOScratchBufferAllocator>, crate::Error> {
self.inner
.scratch_buffer_allocator()
.map(|value| value.map(crate::metal::IOScratchBufferAllocator::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_scratch_buffer_allocator(
&self,
value: Option<&crate::metal::IOScratchBufferAllocator>,
) -> Result<(), crate::Error> {
self.inner
.set_scratch_buffer_allocator(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IOFileHandle {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IOFileHandle,
}
impl IOFileHandle {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IOFileHandle,
) -> Self {
Self { inner }
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IOScratchBuffer {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IOScratchBuffer,
}
impl IOScratchBuffer {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IOScratchBuffer,
) -> Self {
Self { inner }
}
pub fn buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IOScratchBufferAllocator {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IOScratchBufferAllocator,
}
impl IOScratchBufferAllocator {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IOScratchBufferAllocator,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct IndirectCommandBuffer {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IndirectCommandBuffer,
}
impl IndirectCommandBuffer {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IndirectCommandBuffer,
) -> Self {
Self { inner }
}
pub fn size(&self) -> Result<usize, crate::Error> {
self.inner.size().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IndirectCommandBufferDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::IndirectCommandBufferDescriptor,
}
impl IndirectCommandBufferDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IndirectCommandBufferDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::IndirectCommandBufferDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn inherit_buffers(&self) -> Result<bool, crate::Error> {
self.inner.inherit_buffers().map_err(crate::Error::from_ffi)
}
pub fn inherit_cull_mode(&self) -> Result<bool, crate::Error> {
self.inner
.inherit_cull_mode()
.map_err(crate::Error::from_ffi)
}
pub fn inherit_depth_bias(&self) -> Result<bool, crate::Error> {
self.inner
.inherit_depth_bias()
.map_err(crate::Error::from_ffi)
}
pub fn inherit_depth_clip_mode(&self) -> Result<bool, crate::Error> {
self.inner
.inherit_depth_clip_mode()
.map_err(crate::Error::from_ffi)
}
pub fn inherit_depth_stencil_state(&self) -> Result<bool, crate::Error> {
self.inner
.inherit_depth_stencil_state()
.map_err(crate::Error::from_ffi)
}
pub fn inherit_front_facing_winding(&self) -> Result<bool, crate::Error> {
self.inner
.inherit_front_facing_winding()
.map_err(crate::Error::from_ffi)
}
pub fn inherit_pipeline_state(&self) -> Result<bool, crate::Error> {
self.inner
.inherit_pipeline_state()
.map_err(crate::Error::from_ffi)
}
pub fn inherit_triangle_fill_mode(&self) -> Result<bool, crate::Error> {
self.inner
.inherit_triangle_fill_mode()
.map_err(crate::Error::from_ffi)
}
pub fn max_fragment_buffer_bind_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_fragment_buffer_bind_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_fragment_buffer_bind_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_fragment_buffer_bind_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_kernel_buffer_bind_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_kernel_buffer_bind_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_kernel_buffer_bind_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_kernel_buffer_bind_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_kernel_threadgroup_memory_bind_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_kernel_threadgroup_memory_bind_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_kernel_threadgroup_memory_bind_count(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_kernel_threadgroup_memory_bind_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_mesh_buffer_bind_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_mesh_buffer_bind_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_mesh_buffer_bind_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_mesh_buffer_bind_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_object_buffer_bind_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_object_buffer_bind_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_object_buffer_bind_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_object_buffer_bind_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_object_threadgroup_memory_bind_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_object_threadgroup_memory_bind_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_object_threadgroup_memory_bind_count(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_object_threadgroup_memory_bind_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_vertex_buffer_bind_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_vertex_buffer_bind_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_vertex_buffer_bind_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_vertex_buffer_bind_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_color_attachment_mapping(&self) -> Result<bool, crate::Error> {
self.inner
.support_color_attachment_mapping()
.map_err(crate::Error::from_ffi)
}
pub fn support_dynamic_attribute_stride(&self) -> Result<bool, crate::Error> {
self.inner
.support_dynamic_attribute_stride()
.map_err(crate::Error::from_ffi)
}
pub fn support_ray_tracing(&self) -> Result<bool, crate::Error> {
self.inner
.support_ray_tracing()
.map_err(crate::Error::from_ffi)
}
pub fn command_types(&self) -> Result<crate::metal::IndirectCommandType, crate::Error> {
self.inner.command_types().map_err(crate::Error::from_ffi)
}
pub fn set_command_types(
&self,
value: crate::metal::IndirectCommandType,
) -> Result<(), crate::Error> {
self.inner
.set_command_types(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_inherit_buffers(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_inherit_buffers(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_inherit_cull_mode(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_inherit_cull_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_inherit_depth_bias(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_inherit_depth_bias(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_inherit_depth_clip_mode(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_inherit_depth_clip_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_inherit_depth_stencil_state(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_inherit_depth_stencil_state(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_inherit_front_facing_winding(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_inherit_front_facing_winding(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_inherit_pipeline_state(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_inherit_pipeline_state(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_inherit_triangle_fill_mode(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_inherit_triangle_fill_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_color_attachment_mapping(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_support_color_attachment_mapping(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_dynamic_attribute_stride(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_support_dynamic_attribute_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_ray_tracing(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_ray_tracing(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IndirectComputeCommand {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IndirectComputeCommand,
}
impl IndirectComputeCommand {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IndirectComputeCommand,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct IndirectInstanceAccelerationStructureDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IndirectInstanceAccelerationStructureDescriptor,
}
impl IndirectInstanceAccelerationStructureDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IndirectInstanceAccelerationStructureDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::IndirectInstanceAccelerationStructureDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn instance_count_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.instance_count_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_count_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_instance_count_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.instance_descriptor_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_buffer_offset(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_stride(&self) -> Result<usize, crate::Error> {
self.inner
.instance_descriptor_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_instance_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_instance_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_instance_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_instance_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_motion_transform_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_motion_transform_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_motion_transform_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_motion_transform_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.motion_transform_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_count_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.motion_transform_count_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_count_buffer_offset(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_count_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_stride(&self) -> Result<usize, crate::Error> {
self.inner
.motion_transform_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_type(
&self,
) -> Result<crate::metal::AccelerationStructureInstanceDescriptorType, crate::Error>
{
self.inner
.instance_descriptor_type()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_type(
&self,
value: crate::metal::AccelerationStructureInstanceDescriptorType,
) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_transformation_matrix_layout(
&self,
) -> Result<crate::metal::MatrixLayout, crate::Error> {
self.inner
.instance_transformation_matrix_layout()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_transformation_matrix_layout(
&self,
value: crate::metal::MatrixLayout,
) -> Result<(), crate::Error> {
self.inner
.set_instance_transformation_matrix_layout(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_type(&self) -> Result<crate::metal::TransformType, crate::Error> {
self.inner
.motion_transform_type()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_type(
&self,
value: crate::metal::TransformType,
) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_count_buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.instance_count_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_count_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_instance_count_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_buffer(
&self,
) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.instance_descriptor_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_buffer(
&self,
) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.motion_transform_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_count_buffer(
&self,
) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.motion_transform_count_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_count_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_count_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IndirectRenderCommand {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IndirectRenderCommand,
}
impl IndirectRenderCommand {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IndirectRenderCommand,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct InstanceAccelerationStructureDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::InstanceAccelerationStructureDescriptor,
}
impl InstanceAccelerationStructureDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::InstanceAccelerationStructureDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::InstanceAccelerationStructureDescriptor::new(
)
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn instance_count(&self) -> Result<usize, crate::Error> {
self.inner.instance_count().map_err(crate::Error::from_ffi)
}
pub fn set_instance_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_instance_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.instance_descriptor_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_buffer_offset(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_stride(&self) -> Result<usize, crate::Error> {
self.inner
.instance_descriptor_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner
.motion_transform_buffer_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_buffer_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_buffer_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_count(&self) -> Result<usize, crate::Error> {
self.inner
.motion_transform_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_stride(&self) -> Result<usize, crate::Error> {
self.inner
.motion_transform_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_type(
&self,
) -> Result<crate::metal::AccelerationStructureInstanceDescriptorType, crate::Error>
{
self.inner
.instance_descriptor_type()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_type(
&self,
value: crate::metal::AccelerationStructureInstanceDescriptorType,
) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_transformation_matrix_layout(
&self,
) -> Result<crate::metal::MatrixLayout, crate::Error> {
self.inner
.instance_transformation_matrix_layout()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_transformation_matrix_layout(
&self,
value: crate::metal::MatrixLayout,
) -> Result<(), crate::Error> {
self.inner
.set_instance_transformation_matrix_layout(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_type(&self) -> Result<crate::metal::TransformType, crate::Error> {
self.inner
.motion_transform_type()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_type(
&self,
value: crate::metal::TransformType,
) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_buffer(
&self,
) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.instance_descriptor_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_buffer(
&self,
) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.motion_transform_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IntersectionFunctionDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IntersectionFunctionDescriptor,
}
impl IntersectionFunctionDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IntersectionFunctionDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::IntersectionFunctionDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IntersectionFunctionTable {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::IntersectionFunctionTable,
}
impl IntersectionFunctionTable {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IntersectionFunctionTable,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct IntersectionFunctionTableDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::IntersectionFunctionTableDescriptor,
}
impl IntersectionFunctionTableDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::IntersectionFunctionTableDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::IntersectionFunctionTableDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn function_count(&self) -> Result<usize, crate::Error> {
self.inner.function_count().map_err(crate::Error::from_ffi)
}
pub fn set_function_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_function_count(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct LinkedFunctions {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::LinkedFunctions,
}
impl LinkedFunctions {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::LinkedFunctions,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::LinkedFunctions::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct LogContainer {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::LogContainer,
}
impl LogContainer {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::LogContainer,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct LogState {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::LogState,
}
impl LogState {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::LogState,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct LogStateDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::LogStateDescriptor,
}
impl LogStateDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::LogStateDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::LogStateDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn buffer_size(&self) -> Result<isize, crate::Error> {
self.inner.buffer_size().map_err(crate::Error::from_ffi)
}
pub fn set_buffer_size(&self, value: isize) -> Result<(), crate::Error> {
self.inner
.set_buffer_size(value)
.map_err(crate::Error::from_ffi)
}
pub fn level(&self) -> Result<crate::metal::LogLevel, crate::Error> {
self.inner.level().map_err(crate::Error::from_ffi)
}
pub fn set_level(&self, value: crate::metal::LogLevel) -> Result<(), crate::Error> {
self.inner.set_level(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct LogicalToPhysicalColorAttachmentMap {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::LogicalToPhysicalColorAttachmentMap,
}
impl LogicalToPhysicalColorAttachmentMap {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::LogicalToPhysicalColorAttachmentMap,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::LogicalToPhysicalColorAttachmentMap::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct MeshRenderPipelineDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::MeshRenderPipelineDescriptor,
}
impl MeshRenderPipelineDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::MeshRenderPipelineDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::MeshRenderPipelineDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn is_alpha_to_coverage_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_alpha_to_coverage_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn is_alpha_to_one_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_alpha_to_one_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn is_rasterization_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_rasterization_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn max_total_threadgroups_per_mesh_grid(&self) -> Result<usize, crate::Error> {
self.inner
.max_total_threadgroups_per_mesh_grid()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_total_threadgroups_per_mesh_grid(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_total_threadgroups_per_mesh_grid(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_total_threads_per_mesh_threadgroup(&self) -> Result<usize, crate::Error> {
self.inner
.max_total_threads_per_mesh_threadgroup()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_total_threads_per_mesh_threadgroup(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_total_threads_per_mesh_threadgroup(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_total_threads_per_object_threadgroup(&self) -> Result<usize, crate::Error> {
self.inner
.max_total_threads_per_object_threadgroup()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_total_threads_per_object_threadgroup(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_total_threads_per_object_threadgroup(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_vertex_amplification_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_vertex_amplification_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_vertex_amplification_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_vertex_amplification_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn mesh_threadgroup_size_is_multiple_of_thread_execution_width(
&self,
) -> Result<bool, crate::Error> {
self.inner
.mesh_threadgroup_size_is_multiple_of_thread_execution_width()
.map_err(crate::Error::from_ffi)
}
pub fn object_threadgroup_size_is_multiple_of_thread_execution_width(
&self,
) -> Result<bool, crate::Error> {
self.inner
.object_threadgroup_size_is_multiple_of_thread_execution_width()
.map_err(crate::Error::from_ffi)
}
pub fn payload_memory_length(&self) -> Result<usize, crate::Error> {
self.inner
.payload_memory_length()
.map_err(crate::Error::from_ffi)
}
pub fn set_payload_memory_length(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_payload_memory_length(value)
.map_err(crate::Error::from_ffi)
}
pub fn raster_sample_count(&self) -> Result<usize, crate::Error> {
self.inner
.raster_sample_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_raster_sample_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_raster_sample_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_indirect_command_buffers(&self) -> Result<bool, crate::Error> {
self.inner
.support_indirect_command_buffers()
.map_err(crate::Error::from_ffi)
}
pub fn depth_attachment_pixel_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.depth_attachment_pixel_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_attachment_pixel_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_depth_attachment_pixel_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn shader_validation(&self) -> Result<crate::metal::ShaderValidation, crate::Error> {
self.inner
.shader_validation()
.map_err(crate::Error::from_ffi)
}
pub fn set_shader_validation(
&self,
value: crate::metal::ShaderValidation,
) -> Result<(), crate::Error> {
self.inner
.set_shader_validation(value)
.map_err(crate::Error::from_ffi)
}
pub fn stencil_attachment_pixel_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.stencil_attachment_pixel_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_stencil_attachment_pixel_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_stencil_attachment_pixel_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn color_attachments(
&self,
) -> Result<Option<crate::metal::RenderPipelineColorAttachmentDescriptorArray>, crate::Error>
{
self.inner
.color_attachments()
.map(|value| {
value.map(crate::metal::RenderPipelineColorAttachmentDescriptorArray::from_ffi)
})
.map_err(crate::Error::from_ffi)
}
pub fn fragment_buffers(
&self,
) -> Result<Option<crate::metal::PipelineBufferDescriptorArray>, crate::Error> {
self.inner
.fragment_buffers()
.map(|value| value.map(crate::metal::PipelineBufferDescriptorArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn fragment_function(&self) -> Result<Option<crate::metal::Function>, crate::Error> {
self.inner
.fragment_function()
.map(|value| value.map(crate::metal::Function::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_fragment_function(
&self,
value: Option<&crate::metal::Function>,
) -> Result<(), crate::Error> {
self.inner
.set_fragment_function(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn fragment_linked_functions(
&self,
) -> Result<Option<crate::metal::LinkedFunctions>, crate::Error> {
self.inner
.fragment_linked_functions()
.map(|value| value.map(crate::metal::LinkedFunctions::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_fragment_linked_functions(
&self,
value: Option<&crate::metal::LinkedFunctions>,
) -> Result<(), crate::Error> {
self.inner
.set_fragment_linked_functions(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn mesh_buffers(
&self,
) -> Result<Option<crate::metal::PipelineBufferDescriptorArray>, crate::Error> {
self.inner
.mesh_buffers()
.map(|value| value.map(crate::metal::PipelineBufferDescriptorArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn mesh_function(&self) -> Result<Option<crate::metal::Function>, crate::Error> {
self.inner
.mesh_function()
.map(|value| value.map(crate::metal::Function::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_mesh_function(
&self,
value: Option<&crate::metal::Function>,
) -> Result<(), crate::Error> {
self.inner
.set_mesh_function(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn mesh_linked_functions(
&self,
) -> Result<Option<crate::metal::LinkedFunctions>, crate::Error> {
self.inner
.mesh_linked_functions()
.map(|value| value.map(crate::metal::LinkedFunctions::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_mesh_linked_functions(
&self,
value: Option<&crate::metal::LinkedFunctions>,
) -> Result<(), crate::Error> {
self.inner
.set_mesh_linked_functions(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn object_buffers(
&self,
) -> Result<Option<crate::metal::PipelineBufferDescriptorArray>, crate::Error> {
self.inner
.object_buffers()
.map(|value| value.map(crate::metal::PipelineBufferDescriptorArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn object_function(&self) -> Result<Option<crate::metal::Function>, crate::Error> {
self.inner
.object_function()
.map(|value| value.map(crate::metal::Function::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_object_function(
&self,
value: Option<&crate::metal::Function>,
) -> Result<(), crate::Error> {
self.inner
.set_object_function(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn object_linked_functions(
&self,
) -> Result<Option<crate::metal::LinkedFunctions>, crate::Error> {
self.inner
.object_linked_functions()
.map(|value| value.map(crate::metal::LinkedFunctions::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_object_linked_functions(
&self,
value: Option<&crate::metal::LinkedFunctions>,
) -> Result<(), crate::Error> {
self.inner
.set_object_linked_functions(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_alpha_to_coverage_enabled(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_alpha_to_coverage_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_alpha_to_one_enabled(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_alpha_to_one_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_mesh_threadgroup_size_is_multiple_of_thread_execution_width(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_mesh_threadgroup_size_is_multiple_of_thread_execution_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_object_threadgroup_size_is_multiple_of_thread_execution_width(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_object_threadgroup_size_is_multiple_of_thread_execution_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_rasterization_enabled(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_rasterization_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_indirect_command_buffers(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_support_indirect_command_buffers(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct MotionKeyframeData {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::MotionKeyframeData,
}
impl MotionKeyframeData {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::MotionKeyframeData,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::MotionKeyframeData::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn offset(&self) -> Result<usize, crate::Error> {
self.inner.offset().map_err(crate::Error::from_ffi)
}
pub fn set_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner.set_offset(value).map_err(crate::Error::from_ffi)
}
pub fn buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_buffer(&self, value: Option<&crate::metal::Buffer>) -> Result<(), crate::Error> {
self.inner
.set_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ObjectPayloadBinding {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ObjectPayloadBinding,
}
impl ObjectPayloadBinding {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ObjectPayloadBinding,
) -> Self {
Self { inner }
}
pub fn object_payload_alignment(&self) -> Result<usize, crate::Error> {
self.inner
.object_payload_alignment()
.map_err(crate::Error::from_ffi)
}
pub fn object_payload_data_size(&self) -> Result<usize, crate::Error> {
self.inner
.object_payload_data_size()
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ParallelRenderCommandEncoder {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ParallelRenderCommandEncoder,
}
impl ParallelRenderCommandEncoder {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ParallelRenderCommandEncoder,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct PipelineBufferDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::PipelineBufferDescriptor,
}
impl PipelineBufferDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::PipelineBufferDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::PipelineBufferDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn mutability(&self) -> Result<crate::metal::Mutability, crate::Error> {
self.inner.mutability().map_err(crate::Error::from_ffi)
}
pub fn set_mutability(&self, value: crate::metal::Mutability) -> Result<(), crate::Error> {
self.inner
.set_mutability(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct PipelineBufferDescriptorArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::PipelineBufferDescriptorArray,
}
impl PipelineBufferDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::PipelineBufferDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::PipelineBufferDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct PointerType {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::PointerType,
}
impl PointerType {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::PointerType,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::PointerType::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn alignment(&self) -> Result<usize, crate::Error> {
self.inner.alignment().map_err(crate::Error::from_ffi)
}
pub fn data_size(&self) -> Result<usize, crate::Error> {
self.inner.data_size().map_err(crate::Error::from_ffi)
}
pub fn element_is_argument_buffer(&self) -> Result<bool, crate::Error> {
self.inner
.element_is_argument_buffer()
.map_err(crate::Error::from_ffi)
}
pub fn access(&self) -> Result<crate::metal::BindingAccess, crate::Error> {
self.inner.access().map_err(crate::Error::from_ffi)
}
pub fn element_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner.element_type().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct PrimitiveAccelerationStructureDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::PrimitiveAccelerationStructureDescriptor,
}
impl PrimitiveAccelerationStructureDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::PrimitiveAccelerationStructureDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::PrimitiveAccelerationStructureDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn motion_end_time(&self) -> Result<f32, crate::Error> {
self.inner.motion_end_time().map_err(crate::Error::from_ffi)
}
pub fn set_motion_end_time(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_motion_end_time(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_keyframe_count(&self) -> Result<usize, crate::Error> {
self.inner
.motion_keyframe_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_keyframe_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_keyframe_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_start_time(&self) -> Result<f32, crate::Error> {
self.inner
.motion_start_time()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_start_time(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_motion_start_time(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_end_border_mode(
&self,
) -> Result<crate::metal::MotionBorderMode, crate::Error> {
self.inner
.motion_end_border_mode()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_end_border_mode(
&self,
value: crate::metal::MotionBorderMode,
) -> Result<(), crate::Error> {
self.inner
.set_motion_end_border_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_start_border_mode(
&self,
) -> Result<crate::metal::MotionBorderMode, crate::Error> {
self.inner
.motion_start_border_mode()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_start_border_mode(
&self,
value: crate::metal::MotionBorderMode,
) -> Result<(), crate::Error> {
self.inner
.set_motion_start_border_mode(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RasterizationRateLayerArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::RasterizationRateLayerArray,
}
impl RasterizationRateLayerArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RasterizationRateLayerArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RasterizationRateLayerArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RasterizationRateLayerDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::RasterizationRateLayerDescriptor,
}
impl RasterizationRateLayerDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RasterizationRateLayerDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RasterizationRateLayerDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn horizontal(
&self,
) -> Result<Option<crate::metal::RasterizationRateSampleArray>, crate::Error> {
self.inner
.horizontal()
.map(|value| value.map(crate::metal::RasterizationRateSampleArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn vertical(
&self,
) -> Result<Option<crate::metal::RasterizationRateSampleArray>, crate::Error> {
self.inner
.vertical()
.map(|value| value.map(crate::metal::RasterizationRateSampleArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RasterizationRateMap {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::RasterizationRateMap,
}
impl RasterizationRateMap {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RasterizationRateMap,
) -> Self {
Self { inner }
}
pub fn layer_count(&self) -> Result<usize, crate::Error> {
self.inner.layer_count().map_err(crate::Error::from_ffi)
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RasterizationRateMapDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::RasterizationRateMapDescriptor,
}
impl RasterizationRateMapDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RasterizationRateMapDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RasterizationRateMapDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn layer_count(&self) -> Result<usize, crate::Error> {
self.inner.layer_count().map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn layers(
&self,
) -> Result<Option<crate::metal::RasterizationRateLayerArray>, crate::Error> {
self.inner
.layers()
.map(|value| value.map(crate::metal::RasterizationRateLayerArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RasterizationRateSampleArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::RasterizationRateSampleArray,
}
impl RasterizationRateSampleArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RasterizationRateSampleArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RasterizationRateSampleArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPassAttachmentDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::RenderPassAttachmentDescriptor,
}
impl RenderPassAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RenderPassAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RenderPassAttachmentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn depth_plane(&self) -> Result<usize, crate::Error> {
self.inner.depth_plane().map_err(crate::Error::from_ffi)
}
pub fn set_depth_plane(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_depth_plane(value)
.map_err(crate::Error::from_ffi)
}
pub fn level(&self) -> Result<usize, crate::Error> {
self.inner.level().map_err(crate::Error::from_ffi)
}
pub fn set_level(&self, value: usize) -> Result<(), crate::Error> {
self.inner.set_level(value).map_err(crate::Error::from_ffi)
}
pub fn resolve_depth_plane(&self) -> Result<usize, crate::Error> {
self.inner
.resolve_depth_plane()
.map_err(crate::Error::from_ffi)
}
pub fn set_resolve_depth_plane(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_resolve_depth_plane(value)
.map_err(crate::Error::from_ffi)
}
pub fn resolve_level(&self) -> Result<usize, crate::Error> {
self.inner.resolve_level().map_err(crate::Error::from_ffi)
}
pub fn set_resolve_level(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_resolve_level(value)
.map_err(crate::Error::from_ffi)
}
pub fn resolve_slice(&self) -> Result<usize, crate::Error> {
self.inner.resolve_slice().map_err(crate::Error::from_ffi)
}
pub fn set_resolve_slice(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_resolve_slice(value)
.map_err(crate::Error::from_ffi)
}
pub fn slice(&self) -> Result<usize, crate::Error> {
self.inner.slice().map_err(crate::Error::from_ffi)
}
pub fn set_slice(&self, value: usize) -> Result<(), crate::Error> {
self.inner.set_slice(value).map_err(crate::Error::from_ffi)
}
pub fn load_action(&self) -> Result<crate::metal::LoadAction, crate::Error> {
self.inner.load_action().map_err(crate::Error::from_ffi)
}
pub fn set_load_action(&self, value: crate::metal::LoadAction) -> Result<(), crate::Error> {
self.inner
.set_load_action(value)
.map_err(crate::Error::from_ffi)
}
pub fn store_action(&self) -> Result<crate::metal::StoreAction, crate::Error> {
self.inner.store_action().map_err(crate::Error::from_ffi)
}
pub fn set_store_action(
&self,
value: crate::metal::StoreAction,
) -> Result<(), crate::Error> {
self.inner
.set_store_action(value)
.map_err(crate::Error::from_ffi)
}
pub fn store_action_options(
&self,
) -> Result<crate::metal::StoreActionOptions, crate::Error> {
self.inner
.store_action_options()
.map_err(crate::Error::from_ffi)
}
pub fn set_store_action_options(
&self,
value: crate::metal::StoreActionOptions,
) -> Result<(), crate::Error> {
self.inner
.set_store_action_options(value)
.map_err(crate::Error::from_ffi)
}
pub fn resolve_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.resolve_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_resolve_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_resolve_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPassColorAttachmentDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::RenderPassColorAttachmentDescriptor,
}
impl RenderPassColorAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RenderPassColorAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RenderPassColorAttachmentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPassColorAttachmentDescriptorArray {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::RenderPassColorAttachmentDescriptorArray,
}
impl RenderPassColorAttachmentDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RenderPassColorAttachmentDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RenderPassColorAttachmentDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPassDepthAttachmentDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::RenderPassDepthAttachmentDescriptor,
}
impl RenderPassDepthAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RenderPassDepthAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RenderPassDepthAttachmentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn clear_depth(&self) -> Result<f64, crate::Error> {
self.inner.clear_depth().map_err(crate::Error::from_ffi)
}
pub fn set_clear_depth(&self, value: f64) -> Result<(), crate::Error> {
self.inner
.set_clear_depth(value)
.map_err(crate::Error::from_ffi)
}
pub fn depth_resolve_filter(
&self,
) -> Result<crate::metal::MultisampleDepthResolveFilter, crate::Error> {
self.inner
.depth_resolve_filter()
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_resolve_filter(
&self,
value: crate::metal::MultisampleDepthResolveFilter,
) -> Result<(), crate::Error> {
self.inner
.set_depth_resolve_filter(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPassSampleBufferAttachmentDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::RenderPassSampleBufferAttachmentDescriptor,
}
impl RenderPassSampleBufferAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RenderPassSampleBufferAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RenderPassSampleBufferAttachmentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn end_of_fragment_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.end_of_fragment_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_end_of_fragment_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_end_of_fragment_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn end_of_vertex_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.end_of_vertex_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_end_of_vertex_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_end_of_vertex_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn start_of_fragment_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.start_of_fragment_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_start_of_fragment_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_start_of_fragment_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn start_of_vertex_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.start_of_vertex_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_start_of_vertex_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_start_of_vertex_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn sample_buffer(
&self,
) -> Result<Option<crate::metal::CounterSampleBuffer>, crate::Error> {
self.inner
.sample_buffer()
.map(|value| value.map(crate::metal::CounterSampleBuffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_sample_buffer(
&self,
value: Option<&crate::metal::CounterSampleBuffer>,
) -> Result<(), crate::Error> {
self.inner
.set_sample_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPassSampleBufferAttachmentDescriptorArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::RenderPassSampleBufferAttachmentDescriptorArray,
}
impl RenderPassSampleBufferAttachmentDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RenderPassSampleBufferAttachmentDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RenderPassSampleBufferAttachmentDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPassStencilAttachmentDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::RenderPassStencilAttachmentDescriptor,
}
impl RenderPassStencilAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RenderPassStencilAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RenderPassStencilAttachmentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn clear_stencil(&self) -> Result<u32, crate::Error> {
self.inner.clear_stencil().map_err(crate::Error::from_ffi)
}
pub fn set_clear_stencil(&self, value: u32) -> Result<(), crate::Error> {
self.inner
.set_clear_stencil(value)
.map_err(crate::Error::from_ffi)
}
pub fn stencil_resolve_filter(
&self,
) -> Result<crate::metal::MultisampleStencilResolveFilter, crate::Error> {
self.inner
.stencil_resolve_filter()
.map_err(crate::Error::from_ffi)
}
pub fn set_stencil_resolve_filter(
&self,
value: crate::metal::MultisampleStencilResolveFilter,
) -> Result<(), crate::Error> {
self.inner
.set_stencil_resolve_filter(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPipelineColorAttachmentDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::RenderPipelineColorAttachmentDescriptor,
}
impl RenderPipelineColorAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RenderPipelineColorAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RenderPipelineColorAttachmentDescriptor::new(
)
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn is_blending_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_blending_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn alpha_blend_operation(&self) -> Result<crate::metal::BlendOperation, crate::Error> {
self.inner
.alpha_blend_operation()
.map_err(crate::Error::from_ffi)
}
pub fn set_alpha_blend_operation(
&self,
value: crate::metal::BlendOperation,
) -> Result<(), crate::Error> {
self.inner
.set_alpha_blend_operation(value)
.map_err(crate::Error::from_ffi)
}
pub fn destination_alpha_blend_factor(
&self,
) -> Result<crate::metal::BlendFactor, crate::Error> {
self.inner
.destination_alpha_blend_factor()
.map_err(crate::Error::from_ffi)
}
pub fn set_destination_alpha_blend_factor(
&self,
value: crate::metal::BlendFactor,
) -> Result<(), crate::Error> {
self.inner
.set_destination_alpha_blend_factor(value)
.map_err(crate::Error::from_ffi)
}
pub fn destination_rgb_blend_factor(
&self,
) -> Result<crate::metal::BlendFactor, crate::Error> {
self.inner
.destination_rgb_blend_factor()
.map_err(crate::Error::from_ffi)
}
pub fn set_destination_rgb_blend_factor(
&self,
value: crate::metal::BlendFactor,
) -> Result<(), crate::Error> {
self.inner
.set_destination_rgb_blend_factor(value)
.map_err(crate::Error::from_ffi)
}
pub fn pixel_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner.pixel_format().map_err(crate::Error::from_ffi)
}
pub fn set_pixel_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_pixel_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn rgb_blend_operation(&self) -> Result<crate::metal::BlendOperation, crate::Error> {
self.inner
.rgb_blend_operation()
.map_err(crate::Error::from_ffi)
}
pub fn set_rgb_blend_operation(
&self,
value: crate::metal::BlendOperation,
) -> Result<(), crate::Error> {
self.inner
.set_rgb_blend_operation(value)
.map_err(crate::Error::from_ffi)
}
pub fn source_alpha_blend_factor(&self) -> Result<crate::metal::BlendFactor, crate::Error> {
self.inner
.source_alpha_blend_factor()
.map_err(crate::Error::from_ffi)
}
pub fn set_source_alpha_blend_factor(
&self,
value: crate::metal::BlendFactor,
) -> Result<(), crate::Error> {
self.inner
.set_source_alpha_blend_factor(value)
.map_err(crate::Error::from_ffi)
}
pub fn source_rgb_blend_factor(&self) -> Result<crate::metal::BlendFactor, crate::Error> {
self.inner
.source_rgb_blend_factor()
.map_err(crate::Error::from_ffi)
}
pub fn set_source_rgb_blend_factor(
&self,
value: crate::metal::BlendFactor,
) -> Result<(), crate::Error> {
self.inner
.set_source_rgb_blend_factor(value)
.map_err(crate::Error::from_ffi)
}
pub fn write_mask(&self) -> Result<crate::metal::ColorWriteMask, crate::Error> {
self.inner.write_mask().map_err(crate::Error::from_ffi)
}
pub fn set_write_mask(
&self,
value: crate::metal::ColorWriteMask,
) -> Result<(), crate::Error> {
self.inner
.set_write_mask(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_blending_enabled(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_blending_enabled(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPipelineColorAttachmentDescriptorArray {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::RenderPipelineColorAttachmentDescriptorArray,
}
impl RenderPipelineColorAttachmentDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RenderPipelineColorAttachmentDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RenderPipelineColorAttachmentDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPipelineFunctionsDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::RenderPipelineFunctionsDescriptor,
}
impl RenderPipelineFunctionsDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RenderPipelineFunctionsDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RenderPipelineFunctionsDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPipelineReflection {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::RenderPipelineReflection,
}
impl RenderPipelineReflection {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::RenderPipelineReflection,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::RenderPipelineReflection::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ResidencySet {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ResidencySet,
}
impl ResidencySet {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ResidencySet,
) -> Self {
Self { inner }
}
pub fn allocated_size(&self) -> Result<u64, crate::Error> {
self.inner.allocated_size().map_err(crate::Error::from_ffi)
}
pub fn allocation_count(&self) -> Result<usize, crate::Error> {
self.inner
.allocation_count()
.map_err(crate::Error::from_ffi)
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ResidencySetDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ResidencySetDescriptor,
}
impl ResidencySetDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ResidencySetDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::ResidencySetDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn initial_capacity(&self) -> Result<usize, crate::Error> {
self.inner
.initial_capacity()
.map_err(crate::Error::from_ffi)
}
pub fn set_initial_capacity(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_initial_capacity(value)
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Resource {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Resource,
}
impl Resource {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Resource,
) -> Self {
Self { inner }
}
pub fn allocated_size(&self) -> Result<usize, crate::Error> {
self.inner.allocated_size().map_err(crate::Error::from_ffi)
}
pub fn heap_offset(&self) -> Result<usize, crate::Error> {
self.inner.heap_offset().map_err(crate::Error::from_ffi)
}
pub fn cpu_cache_mode(&self) -> Result<crate::metal::CPUCacheMode, crate::Error> {
self.inner.cpu_cache_mode().map_err(crate::Error::from_ffi)
}
pub fn hazard_tracking_mode(
&self,
) -> Result<crate::metal::HazardTrackingMode, crate::Error> {
self.inner
.hazard_tracking_mode()
.map_err(crate::Error::from_ffi)
}
pub fn resource_options(&self) -> Result<crate::metal::ResourceOptions, crate::Error> {
self.inner
.resource_options()
.map_err(crate::Error::from_ffi)
}
pub fn storage_mode(&self) -> Result<crate::metal::StorageMode, crate::Error> {
self.inner.storage_mode().map_err(crate::Error::from_ffi)
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn heap(&self) -> Result<Option<crate::metal::Heap>, crate::Error> {
self.inner
.heap()
.map(|value| value.map(crate::metal::Heap::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ResourceStateCommandEncoder {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ResourceStateCommandEncoder,
}
impl ResourceStateCommandEncoder {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ResourceStateCommandEncoder,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct ResourceStatePassDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ResourceStatePassDescriptor,
}
impl ResourceStatePassDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ResourceStatePassDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::ResourceStatePassDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn sample_buffer_attachments(
&self,
) -> Result<
Option<crate::metal::ResourceStatePassSampleBufferAttachmentDescriptorArray>,
crate::Error,
> {
self.inner.sample_buffer_attachments()
.map(|value| value.map(crate::metal::ResourceStatePassSampleBufferAttachmentDescriptorArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ResourceStatePassSampleBufferAttachmentDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ResourceStatePassSampleBufferAttachmentDescriptor,
}
impl ResourceStatePassSampleBufferAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ResourceStatePassSampleBufferAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::ResourceStatePassSampleBufferAttachmentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn end_of_encoder_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.end_of_encoder_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_end_of_encoder_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_end_of_encoder_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn start_of_encoder_sample_index(&self) -> Result<usize, crate::Error> {
self.inner
.start_of_encoder_sample_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_start_of_encoder_sample_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_start_of_encoder_sample_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn sample_buffer(
&self,
) -> Result<Option<crate::metal::CounterSampleBuffer>, crate::Error> {
self.inner
.sample_buffer()
.map(|value| value.map(crate::metal::CounterSampleBuffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_sample_buffer(
&self,
value: Option<&crate::metal::CounterSampleBuffer>,
) -> Result<(), crate::Error> {
self.inner
.set_sample_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ResourceStatePassSampleBufferAttachmentDescriptorArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ResourceStatePassSampleBufferAttachmentDescriptorArray,
}
impl ResourceStatePassSampleBufferAttachmentDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ResourceStatePassSampleBufferAttachmentDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::ResourceStatePassSampleBufferAttachmentDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ResourceViewPool {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ResourceViewPool,
}
impl ResourceViewPool {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ResourceViewPool,
) -> Self {
Self { inner }
}
pub fn resource_view_count(&self) -> Result<usize, crate::Error> {
self.inner
.resource_view_count()
.map_err(crate::Error::from_ffi)
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ResourceViewPoolDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ResourceViewPoolDescriptor,
}
impl ResourceViewPoolDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ResourceViewPoolDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::ResourceViewPoolDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn resource_view_count(&self) -> Result<usize, crate::Error> {
self.inner
.resource_view_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_resource_view_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_resource_view_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct SamplerDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::SamplerDescriptor,
}
impl SamplerDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::SamplerDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::SamplerDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn lod_average(&self) -> Result<bool, crate::Error> {
self.inner.lod_average().map_err(crate::Error::from_ffi)
}
pub fn lod_bias(&self) -> Result<f32, crate::Error> {
self.inner.lod_bias().map_err(crate::Error::from_ffi)
}
pub fn set_lod_bias(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_lod_bias(value)
.map_err(crate::Error::from_ffi)
}
pub fn lod_max_clamp(&self) -> Result<f32, crate::Error> {
self.inner.lod_max_clamp().map_err(crate::Error::from_ffi)
}
pub fn set_lod_max_clamp(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_lod_max_clamp(value)
.map_err(crate::Error::from_ffi)
}
pub fn lod_min_clamp(&self) -> Result<f32, crate::Error> {
self.inner.lod_min_clamp().map_err(crate::Error::from_ffi)
}
pub fn set_lod_min_clamp(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_lod_min_clamp(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_anisotropy(&self) -> Result<usize, crate::Error> {
self.inner.max_anisotropy().map_err(crate::Error::from_ffi)
}
pub fn set_max_anisotropy(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_anisotropy(value)
.map_err(crate::Error::from_ffi)
}
pub fn normalized_coordinates(&self) -> Result<bool, crate::Error> {
self.inner
.normalized_coordinates()
.map_err(crate::Error::from_ffi)
}
pub fn support_argument_buffers(&self) -> Result<bool, crate::Error> {
self.inner
.support_argument_buffers()
.map_err(crate::Error::from_ffi)
}
pub fn border_color(&self) -> Result<crate::metal::SamplerBorderColor, crate::Error> {
self.inner.border_color().map_err(crate::Error::from_ffi)
}
pub fn set_border_color(
&self,
value: crate::metal::SamplerBorderColor,
) -> Result<(), crate::Error> {
self.inner
.set_border_color(value)
.map_err(crate::Error::from_ffi)
}
pub fn compare_function(&self) -> Result<crate::metal::CompareFunction, crate::Error> {
self.inner
.compare_function()
.map_err(crate::Error::from_ffi)
}
pub fn set_compare_function(
&self,
value: crate::metal::CompareFunction,
) -> Result<(), crate::Error> {
self.inner
.set_compare_function(value)
.map_err(crate::Error::from_ffi)
}
pub fn mag_filter(&self) -> Result<crate::metal::SamplerMinMagFilter, crate::Error> {
self.inner.mag_filter().map_err(crate::Error::from_ffi)
}
pub fn set_mag_filter(
&self,
value: crate::metal::SamplerMinMagFilter,
) -> Result<(), crate::Error> {
self.inner
.set_mag_filter(value)
.map_err(crate::Error::from_ffi)
}
pub fn min_filter(&self) -> Result<crate::metal::SamplerMinMagFilter, crate::Error> {
self.inner.min_filter().map_err(crate::Error::from_ffi)
}
pub fn set_min_filter(
&self,
value: crate::metal::SamplerMinMagFilter,
) -> Result<(), crate::Error> {
self.inner
.set_min_filter(value)
.map_err(crate::Error::from_ffi)
}
pub fn mip_filter(&self) -> Result<crate::metal::SamplerMipFilter, crate::Error> {
self.inner.mip_filter().map_err(crate::Error::from_ffi)
}
pub fn set_mip_filter(
&self,
value: crate::metal::SamplerMipFilter,
) -> Result<(), crate::Error> {
self.inner
.set_mip_filter(value)
.map_err(crate::Error::from_ffi)
}
pub fn reduction_mode(&self) -> Result<crate::metal::SamplerReductionMode, crate::Error> {
self.inner.reduction_mode().map_err(crate::Error::from_ffi)
}
pub fn set_reduction_mode(
&self,
value: crate::metal::SamplerReductionMode,
) -> Result<(), crate::Error> {
self.inner
.set_reduction_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn s_address_mode(&self) -> Result<crate::metal::SamplerAddressMode, crate::Error> {
self.inner.s_address_mode().map_err(crate::Error::from_ffi)
}
pub fn set_s_address_mode(
&self,
value: crate::metal::SamplerAddressMode,
) -> Result<(), crate::Error> {
self.inner
.set_s_address_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn t_address_mode(&self) -> Result<crate::metal::SamplerAddressMode, crate::Error> {
self.inner.t_address_mode().map_err(crate::Error::from_ffi)
}
pub fn set_t_address_mode(
&self,
value: crate::metal::SamplerAddressMode,
) -> Result<(), crate::Error> {
self.inner
.set_t_address_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn set_lod_average(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_lod_average(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_normalized_coordinates(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_normalized_coordinates(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_argument_buffers(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_argument_buffers(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct SamplerState {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::SamplerState,
}
impl SamplerState {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::SamplerState,
) -> Self {
Self { inner }
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct SharedEvent {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::SharedEvent,
}
impl SharedEvent {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::SharedEvent,
) -> Self {
Self { inner }
}
pub fn signaled_value(&self) -> Result<u64, crate::Error> {
self.inner.signaled_value().map_err(crate::Error::from_ffi)
}
pub fn set_signaled_value(&self, value: u64) -> Result<(), crate::Error> {
self.inner
.set_signaled_value(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct SharedEventHandle {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::SharedEventHandle,
}
impl SharedEventHandle {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::SharedEventHandle,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::SharedEventHandle::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct SharedEventListener {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::SharedEventListener,
}
impl SharedEventListener {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::SharedEventListener,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::SharedEventListener::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct SharedTextureHandle {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::SharedTextureHandle,
}
impl SharedTextureHandle {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::SharedTextureHandle,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::SharedTextureHandle::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct StageInputOutputDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::StageInputOutputDescriptor,
}
impl StageInputOutputDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::StageInputOutputDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::StageInputOutputDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn index_buffer_index(&self) -> Result<usize, crate::Error> {
self.inner
.index_buffer_index()
.map_err(crate::Error::from_ffi)
}
pub fn set_index_buffer_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_index_buffer_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_type(&self) -> Result<crate::metal::IndexType, crate::Error> {
self.inner.index_type().map_err(crate::Error::from_ffi)
}
pub fn set_index_type(&self, value: crate::metal::IndexType) -> Result<(), crate::Error> {
self.inner
.set_index_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn attributes(
&self,
) -> Result<Option<crate::metal::AttributeDescriptorArray>, crate::Error> {
self.inner
.attributes()
.map(|value| value.map(crate::metal::AttributeDescriptorArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn layouts(
&self,
) -> Result<Option<crate::metal::BufferLayoutDescriptorArray>, crate::Error> {
self.inner
.layouts()
.map(|value| value.map(crate::metal::BufferLayoutDescriptorArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct StencilDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::StencilDescriptor,
}
impl StencilDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::StencilDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::StencilDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn read_mask(&self) -> Result<u32, crate::Error> {
self.inner.read_mask().map_err(crate::Error::from_ffi)
}
pub fn set_read_mask(&self, value: u32) -> Result<(), crate::Error> {
self.inner
.set_read_mask(value)
.map_err(crate::Error::from_ffi)
}
pub fn write_mask(&self) -> Result<u32, crate::Error> {
self.inner.write_mask().map_err(crate::Error::from_ffi)
}
pub fn set_write_mask(&self, value: u32) -> Result<(), crate::Error> {
self.inner
.set_write_mask(value)
.map_err(crate::Error::from_ffi)
}
pub fn depth_failure_operation(
&self,
) -> Result<crate::metal::StencilOperation, crate::Error> {
self.inner
.depth_failure_operation()
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_failure_operation(
&self,
value: crate::metal::StencilOperation,
) -> Result<(), crate::Error> {
self.inner
.set_depth_failure_operation(value)
.map_err(crate::Error::from_ffi)
}
pub fn depth_stencil_pass_operation(
&self,
) -> Result<crate::metal::StencilOperation, crate::Error> {
self.inner
.depth_stencil_pass_operation()
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_stencil_pass_operation(
&self,
value: crate::metal::StencilOperation,
) -> Result<(), crate::Error> {
self.inner
.set_depth_stencil_pass_operation(value)
.map_err(crate::Error::from_ffi)
}
pub fn stencil_compare_function(
&self,
) -> Result<crate::metal::CompareFunction, crate::Error> {
self.inner
.stencil_compare_function()
.map_err(crate::Error::from_ffi)
}
pub fn set_stencil_compare_function(
&self,
value: crate::metal::CompareFunction,
) -> Result<(), crate::Error> {
self.inner
.set_stencil_compare_function(value)
.map_err(crate::Error::from_ffi)
}
pub fn stencil_failure_operation(
&self,
) -> Result<crate::metal::StencilOperation, crate::Error> {
self.inner
.stencil_failure_operation()
.map_err(crate::Error::from_ffi)
}
pub fn set_stencil_failure_operation(
&self,
value: crate::metal::StencilOperation,
) -> Result<(), crate::Error> {
self.inner
.set_stencil_failure_operation(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct StitchedLibraryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::StitchedLibraryDescriptor,
}
impl StitchedLibraryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::StitchedLibraryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::StitchedLibraryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn options(&self) -> Result<crate::metal::StitchedLibraryOptions, crate::Error> {
self.inner.options().map_err(crate::Error::from_ffi)
}
pub fn set_options(
&self,
value: crate::metal::StitchedLibraryOptions,
) -> Result<(), crate::Error> {
self.inner
.set_options(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct StructMember {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::StructMember,
}
impl StructMember {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::StructMember,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::StructMember::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn argument_index(&self) -> Result<usize, crate::Error> {
self.inner.argument_index().map_err(crate::Error::from_ffi)
}
pub fn offset(&self) -> Result<usize, crate::Error> {
self.inner.offset().map_err(crate::Error::from_ffi)
}
pub fn data_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner.data_type().map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct StructType {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::StructType,
}
impl StructType {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::StructType,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::StructType::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Tensor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Tensor,
}
impl Tensor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Tensor,
) -> Self {
Self { inner }
}
pub fn buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner.buffer_offset().map_err(crate::Error::from_ffi)
}
pub fn data_type(&self) -> Result<crate::metal::TensorDataType, crate::Error> {
self.inner.data_type().map_err(crate::Error::from_ffi)
}
pub fn usage(&self) -> Result<crate::metal::TensorUsage, crate::Error> {
self.inner.usage().map_err(crate::Error::from_ffi)
}
pub fn buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn dimensions(&self) -> Result<Option<crate::metal::TensorExtents>, crate::Error> {
self.inner
.dimensions()
.map(|value| value.map(crate::metal::TensorExtents::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn strides(&self) -> Result<Option<crate::metal::TensorExtents>, crate::Error> {
self.inner
.strides()
.map(|value| value.map(crate::metal::TensorExtents::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TensorAuxiliaryPlane {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TensorAuxiliaryPlane,
}
impl TensorAuxiliaryPlane {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TensorAuxiliaryPlane,
) -> Self {
Self { inner }
}
pub fn buffer_offset(&self) -> Result<usize, crate::Error> {
self.inner.buffer_offset().map_err(crate::Error::from_ffi)
}
pub fn data_type(&self) -> Result<crate::metal::TensorDataType, crate::Error> {
self.inner.data_type().map_err(crate::Error::from_ffi)
}
pub fn plane_type(&self) -> Result<crate::metal::TensorPlaneType, crate::Error> {
self.inner.plane_type().map_err(crate::Error::from_ffi)
}
pub fn block_factors(&self) -> Result<Option<crate::metal::TensorExtents>, crate::Error> {
self.inner
.block_factors()
.map(|value| value.map(crate::metal::TensorExtents::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn buffer(&self) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TensorAuxiliaryPlaneDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TensorAuxiliaryPlaneDescriptor,
}
impl TensorAuxiliaryPlaneDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TensorAuxiliaryPlaneDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TensorAuxiliaryPlaneDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn data_type(&self) -> Result<crate::metal::TensorDataType, crate::Error> {
self.inner.data_type().map_err(crate::Error::from_ffi)
}
pub fn set_data_type(
&self,
value: crate::metal::TensorDataType,
) -> Result<(), crate::Error> {
self.inner
.set_data_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn block_factors(&self) -> Result<Option<crate::metal::TensorExtents>, crate::Error> {
self.inner
.block_factors()
.map(|value| value.map(crate::metal::TensorExtents::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_block_factors(
&self,
value: Option<&crate::metal::TensorExtents>,
) -> Result<(), crate::Error> {
self.inner
.set_block_factors(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TensorAuxiliaryPlaneDescriptorMap {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::TensorAuxiliaryPlaneDescriptorMap,
}
impl TensorAuxiliaryPlaneDescriptorMap {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TensorAuxiliaryPlaneDescriptorMap,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TensorAuxiliaryPlaneDescriptorMap::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TensorAuxiliaryPlaneType {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TensorAuxiliaryPlaneType,
}
impl TensorAuxiliaryPlaneType {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TensorAuxiliaryPlaneType,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TensorAuxiliaryPlaneType::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn data_type(&self) -> Result<crate::metal::TensorDataType, crate::Error> {
self.inner.data_type().map_err(crate::Error::from_ffi)
}
pub fn plane_type(&self) -> Result<crate::metal::TensorPlaneType, crate::Error> {
self.inner.plane_type().map_err(crate::Error::from_ffi)
}
pub fn block_factors(&self) -> Result<Option<crate::metal::TensorExtents>, crate::Error> {
self.inner
.block_factors()
.map(|value| value.map(crate::metal::TensorExtents::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TensorBinding {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TensorBinding,
}
impl TensorBinding {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TensorBinding,
) -> Self {
Self { inner }
}
pub fn index_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner.index_type().map_err(crate::Error::from_ffi)
}
pub fn tensor_data_type(&self) -> Result<crate::metal::TensorDataType, crate::Error> {
self.inner
.tensor_data_type()
.map_err(crate::Error::from_ffi)
}
pub fn dimensions(&self) -> Result<Option<crate::metal::TensorExtents>, crate::Error> {
self.inner
.dimensions()
.map(|value| value.map(crate::metal::TensorExtents::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TensorBufferAttachments {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TensorBufferAttachments,
}
impl TensorBufferAttachments {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TensorBufferAttachments,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TensorBufferAttachments::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TensorDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TensorDescriptor,
}
impl TensorDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TensorDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TensorDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn cpu_cache_mode(&self) -> Result<crate::metal::CPUCacheMode, crate::Error> {
self.inner.cpu_cache_mode().map_err(crate::Error::from_ffi)
}
pub fn set_cpu_cache_mode(
&self,
value: crate::metal::CPUCacheMode,
) -> Result<(), crate::Error> {
self.inner
.set_cpu_cache_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn data_type(&self) -> Result<crate::metal::TensorDataType, crate::Error> {
self.inner.data_type().map_err(crate::Error::from_ffi)
}
pub fn set_data_type(
&self,
value: crate::metal::TensorDataType,
) -> Result<(), crate::Error> {
self.inner
.set_data_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn hazard_tracking_mode(
&self,
) -> Result<crate::metal::HazardTrackingMode, crate::Error> {
self.inner
.hazard_tracking_mode()
.map_err(crate::Error::from_ffi)
}
pub fn set_hazard_tracking_mode(
&self,
value: crate::metal::HazardTrackingMode,
) -> Result<(), crate::Error> {
self.inner
.set_hazard_tracking_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn resource_options(&self) -> Result<crate::metal::ResourceOptions, crate::Error> {
self.inner
.resource_options()
.map_err(crate::Error::from_ffi)
}
pub fn set_resource_options(
&self,
value: crate::metal::ResourceOptions,
) -> Result<(), crate::Error> {
self.inner
.set_resource_options(value)
.map_err(crate::Error::from_ffi)
}
pub fn storage_mode(&self) -> Result<crate::metal::StorageMode, crate::Error> {
self.inner.storage_mode().map_err(crate::Error::from_ffi)
}
pub fn set_storage_mode(
&self,
value: crate::metal::StorageMode,
) -> Result<(), crate::Error> {
self.inner
.set_storage_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn usage(&self) -> Result<crate::metal::TensorUsage, crate::Error> {
self.inner.usage().map_err(crate::Error::from_ffi)
}
pub fn set_usage(&self, value: crate::metal::TensorUsage) -> Result<(), crate::Error> {
self.inner.set_usage(value).map_err(crate::Error::from_ffi)
}
pub fn auxiliary_planes(
&self,
) -> Result<Option<crate::metal::TensorAuxiliaryPlaneDescriptorMap>, crate::Error> {
self.inner
.auxiliary_planes()
.map(|value| value.map(crate::metal::TensorAuxiliaryPlaneDescriptorMap::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_auxiliary_planes(
&self,
value: Option<&crate::metal::TensorAuxiliaryPlaneDescriptorMap>,
) -> Result<(), crate::Error> {
self.inner
.set_auxiliary_planes(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn dimensions(&self) -> Result<Option<crate::metal::TensorExtents>, crate::Error> {
self.inner
.dimensions()
.map(|value| value.map(crate::metal::TensorExtents::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_dimensions(
&self,
value: Option<&crate::metal::TensorExtents>,
) -> Result<(), crate::Error> {
self.inner
.set_dimensions(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn strides(&self) -> Result<Option<crate::metal::TensorExtents>, crate::Error> {
self.inner
.strides()
.map(|value| value.map(crate::metal::TensorExtents::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_strides(
&self,
value: Option<&crate::metal::TensorExtents>,
) -> Result<(), crate::Error> {
self.inner
.set_strides(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TensorExtents {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TensorExtents,
}
impl TensorExtents {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TensorExtents,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TensorExtents::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn rank(&self) -> Result<usize, crate::Error> {
self.inner.rank().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TensorReferenceType {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TensorReferenceType,
}
impl TensorReferenceType {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TensorReferenceType,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TensorReferenceType::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn access(&self) -> Result<crate::metal::BindingAccess, crate::Error> {
self.inner.access().map_err(crate::Error::from_ffi)
}
pub fn index_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner.index_type().map_err(crate::Error::from_ffi)
}
pub fn tensor_data_type(&self) -> Result<crate::metal::TensorDataType, crate::Error> {
self.inner
.tensor_data_type()
.map_err(crate::Error::from_ffi)
}
pub fn dimensions(&self) -> Result<Option<crate::metal::TensorExtents>, crate::Error> {
self.inner
.dimensions()
.map(|value| value.map(crate::metal::TensorExtents::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TextureBinding {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TextureBinding,
}
impl TextureBinding {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TextureBinding,
) -> Self {
Self { inner }
}
pub fn array_length(&self) -> Result<usize, crate::Error> {
self.inner.array_length().map_err(crate::Error::from_ffi)
}
pub fn is_depth_texture(&self) -> Result<bool, crate::Error> {
self.inner
.is_depth_texture()
.map_err(crate::Error::from_ffi)
}
pub fn texture_data_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner
.texture_data_type()
.map_err(crate::Error::from_ffi)
}
pub fn texture_type(&self) -> Result<crate::metal::TextureType, crate::Error> {
self.inner.texture_type().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TextureReferenceType {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TextureReferenceType,
}
impl TextureReferenceType {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TextureReferenceType,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TextureReferenceType::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn is_depth_texture(&self) -> Result<bool, crate::Error> {
self.inner
.is_depth_texture()
.map_err(crate::Error::from_ffi)
}
pub fn access(&self) -> Result<crate::metal::BindingAccess, crate::Error> {
self.inner.access().map_err(crate::Error::from_ffi)
}
pub fn texture_data_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner
.texture_data_type()
.map_err(crate::Error::from_ffi)
}
pub fn texture_type(&self) -> Result<crate::metal::TextureType, crate::Error> {
self.inner.texture_type().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TextureViewDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TextureViewDescriptor,
}
impl TextureViewDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TextureViewDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TextureViewDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn pixel_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner.pixel_format().map_err(crate::Error::from_ffi)
}
pub fn set_pixel_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_pixel_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn texture_type(&self) -> Result<crate::metal::TextureType, crate::Error> {
self.inner.texture_type().map_err(crate::Error::from_ffi)
}
pub fn set_texture_type(
&self,
value: crate::metal::TextureType,
) -> Result<(), crate::Error> {
self.inner
.set_texture_type(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TextureViewPool {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TextureViewPool,
}
impl TextureViewPool {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TextureViewPool,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct ThreadgroupBinding {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::ThreadgroupBinding,
}
impl ThreadgroupBinding {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::ThreadgroupBinding,
) -> Self {
Self { inner }
}
pub fn threadgroup_memory_alignment(&self) -> Result<usize, crate::Error> {
self.inner
.threadgroup_memory_alignment()
.map_err(crate::Error::from_ffi)
}
pub fn threadgroup_memory_data_size(&self) -> Result<usize, crate::Error> {
self.inner
.threadgroup_memory_data_size()
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TileRenderPipelineColorAttachmentDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::TileRenderPipelineColorAttachmentDescriptor,
}
impl TileRenderPipelineColorAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TileRenderPipelineColorAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TileRenderPipelineColorAttachmentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn pixel_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner.pixel_format().map_err(crate::Error::from_ffi)
}
pub fn set_pixel_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_pixel_format(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TileRenderPipelineColorAttachmentDescriptorArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TileRenderPipelineColorAttachmentDescriptorArray,
}
impl TileRenderPipelineColorAttachmentDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TileRenderPipelineColorAttachmentDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TileRenderPipelineColorAttachmentDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TileRenderPipelineDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::TileRenderPipelineDescriptor,
}
impl TileRenderPipelineDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::TileRenderPipelineDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::TileRenderPipelineDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn max_call_stack_depth(&self) -> Result<usize, crate::Error> {
self.inner
.max_call_stack_depth()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_call_stack_depth(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_call_stack_depth(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_total_threads_per_threadgroup(&self) -> Result<usize, crate::Error> {
self.inner
.max_total_threads_per_threadgroup()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_total_threads_per_threadgroup(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_total_threads_per_threadgroup(value)
.map_err(crate::Error::from_ffi)
}
pub fn raster_sample_count(&self) -> Result<usize, crate::Error> {
self.inner
.raster_sample_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_raster_sample_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_raster_sample_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_adding_binary_functions(&self) -> Result<bool, crate::Error> {
self.inner
.support_adding_binary_functions()
.map_err(crate::Error::from_ffi)
}
pub fn threadgroup_size_matches_tile_size(&self) -> Result<bool, crate::Error> {
self.inner
.threadgroup_size_matches_tile_size()
.map_err(crate::Error::from_ffi)
}
pub fn shader_validation(&self) -> Result<crate::metal::ShaderValidation, crate::Error> {
self.inner
.shader_validation()
.map_err(crate::Error::from_ffi)
}
pub fn set_shader_validation(
&self,
value: crate::metal::ShaderValidation,
) -> Result<(), crate::Error> {
self.inner
.set_shader_validation(value)
.map_err(crate::Error::from_ffi)
}
pub fn color_attachments(
&self,
) -> Result<
Option<crate::metal::TileRenderPipelineColorAttachmentDescriptorArray>,
crate::Error,
> {
self.inner
.color_attachments()
.map(|value| {
value.map(
crate::metal::TileRenderPipelineColorAttachmentDescriptorArray::from_ffi,
)
})
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn linked_functions(
&self,
) -> Result<Option<crate::metal::LinkedFunctions>, crate::Error> {
self.inner
.linked_functions()
.map(|value| value.map(crate::metal::LinkedFunctions::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_linked_functions(
&self,
value: Option<&crate::metal::LinkedFunctions>,
) -> Result<(), crate::Error> {
self.inner
.set_linked_functions(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn tile_buffers(
&self,
) -> Result<Option<crate::metal::PipelineBufferDescriptorArray>, crate::Error> {
self.inner
.tile_buffers()
.map(|value| value.map(crate::metal::PipelineBufferDescriptorArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn tile_function(&self) -> Result<Option<crate::metal::Function>, crate::Error> {
self.inner
.tile_function()
.map(|value| value.map(crate::metal::Function::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_tile_function(
&self,
value: Option<&crate::metal::Function>,
) -> Result<(), crate::Error> {
self.inner
.set_tile_function(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_support_adding_binary_functions(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_adding_binary_functions(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_threadgroup_size_matches_tile_size(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_threadgroup_size_matches_tile_size(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Type {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::Type,
}
impl Type {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::Type,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::Type::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn data_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner.data_type().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct VertexAttribute {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::VertexAttribute,
}
impl VertexAttribute {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::VertexAttribute,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::VertexAttribute::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn attribute_index(&self) -> Result<usize, crate::Error> {
self.inner.attribute_index().map_err(crate::Error::from_ffi)
}
pub fn is_active(&self) -> Result<bool, crate::Error> {
self.inner.is_active().map_err(crate::Error::from_ffi)
}
pub fn is_patch_control_point_data(&self) -> Result<bool, crate::Error> {
self.inner
.is_patch_control_point_data()
.map_err(crate::Error::from_ffi)
}
pub fn is_patch_data(&self) -> Result<bool, crate::Error> {
self.inner.is_patch_data().map_err(crate::Error::from_ffi)
}
pub fn attribute_type(&self) -> Result<crate::metal::DataType, crate::Error> {
self.inner.attribute_type().map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct VertexAttributeDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::VertexAttributeDescriptor,
}
impl VertexAttributeDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::VertexAttributeDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::VertexAttributeDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn buffer_index(&self) -> Result<usize, crate::Error> {
self.inner.buffer_index().map_err(crate::Error::from_ffi)
}
pub fn set_buffer_index(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_buffer_index(value)
.map_err(crate::Error::from_ffi)
}
pub fn offset(&self) -> Result<usize, crate::Error> {
self.inner.offset().map_err(crate::Error::from_ffi)
}
pub fn set_offset(&self, value: usize) -> Result<(), crate::Error> {
self.inner.set_offset(value).map_err(crate::Error::from_ffi)
}
pub fn format(&self) -> Result<crate::metal::VertexFormat, crate::Error> {
self.inner.format().map_err(crate::Error::from_ffi)
}
pub fn set_format(&self, value: crate::metal::VertexFormat) -> Result<(), crate::Error> {
self.inner.set_format(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct VertexAttributeDescriptorArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::VertexAttributeDescriptorArray,
}
impl VertexAttributeDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::VertexAttributeDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::VertexAttributeDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct VertexBufferLayoutDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::VertexBufferLayoutDescriptor,
}
impl VertexBufferLayoutDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::VertexBufferLayoutDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::VertexBufferLayoutDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn step_rate(&self) -> Result<usize, crate::Error> {
self.inner.step_rate().map_err(crate::Error::from_ffi)
}
pub fn set_step_rate(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_step_rate(value)
.map_err(crate::Error::from_ffi)
}
pub fn stride(&self) -> Result<usize, crate::Error> {
self.inner.stride().map_err(crate::Error::from_ffi)
}
pub fn set_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner.set_stride(value).map_err(crate::Error::from_ffi)
}
pub fn step_function(&self) -> Result<crate::metal::VertexStepFunction, crate::Error> {
self.inner.step_function().map_err(crate::Error::from_ffi)
}
pub fn set_step_function(
&self,
value: crate::metal::VertexStepFunction,
) -> Result<(), crate::Error> {
self.inner
.set_step_function(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct VertexBufferLayoutDescriptorArray {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal::VertexBufferLayoutDescriptorArray,
}
impl VertexBufferLayoutDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::VertexBufferLayoutDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::VertexBufferLayoutDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct VertexDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::VertexDescriptor,
}
impl VertexDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::VertexDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::VertexDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn attributes(
&self,
) -> Result<Option<crate::metal::VertexAttributeDescriptorArray>, crate::Error> {
self.inner
.attributes()
.map(|value| value.map(crate::metal::VertexAttributeDescriptorArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn layouts(
&self,
) -> Result<Option<crate::metal::VertexBufferLayoutDescriptorArray>, crate::Error> {
self.inner
.layouts()
.map(|value| value.map(crate::metal::VertexBufferLayoutDescriptorArray::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct VisibleFunctionTable {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::VisibleFunctionTable,
}
impl VisibleFunctionTable {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::VisibleFunctionTable,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct VisibleFunctionTableDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal::VisibleFunctionTableDescriptor,
}
impl VisibleFunctionTableDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal::VisibleFunctionTableDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal::VisibleFunctionTableDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn function_count(&self) -> Result<usize, crate::Error> {
self.inner.function_count().map_err(crate::Error::from_ffi)
}
pub fn set_function_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_function_count(value)
.map_err(crate::Error::from_ffi)
}
}
}
pub(crate) mod metal4 {
pub use metal_rust_ffi::__private::structs::BufferRange;
pub use metal_rust_ffi::__private::structs::CopySparseBufferMappingOperation;
pub use metal_rust_ffi::__private::structs::CopySparseTextureMappingOperation;
pub use metal_rust_ffi::__private::structs::TimestampHeapEntry;
pub use metal_rust_ffi::__private::structs::UpdateSparseBufferMappingOperation;
pub use metal_rust_ffi::__private::structs::UpdateSparseTextureMappingOperation;
pub use metal_rust_ffi::__private::values::AlphaToCoverageState;
pub use metal_rust_ffi::__private::values::AlphaToOneState;
pub use metal_rust_ffi::__private::values::BinaryFunctionOptions;
pub use metal_rust_ffi::__private::values::BlendState;
pub use metal_rust_ffi::__private::values::CommandQueueError;
pub use metal_rust_ffi::__private::values::CompilerTaskStatus;
pub use metal_rust_ffi::__private::values::CounterHeapType;
pub use metal_rust_ffi::__private::values::IndirectCommandBufferSupportState;
pub use metal_rust_ffi::__private::values::LogicalToPhysicalColorAttachmentMappingState;
pub use metal_rust_ffi::__private::values::PipelineDataSetSerializerConfiguration;
pub use metal_rust_ffi::__private::values::RenderEncoderOptions;
pub use metal_rust_ffi::__private::values::ShaderReflection;
pub use metal_rust_ffi::__private::values::TimestampGranularity;
pub use metal_rust_ffi::__private::values::VisibilityOptions;
#[derive(Clone)]
pub struct AccelerationStructureBoundingBoxGeometryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureBoundingBoxGeometryDescriptor,
}
impl AccelerationStructureBoundingBoxGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureBoundingBoxGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::AccelerationStructureBoundingBoxGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn bounding_box_count(&self) -> Result<usize, crate::Error> {
self.inner
.bounding_box_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_bounding_box_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_bounding_box_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn bounding_box_stride(&self) -> Result<usize, crate::Error> {
self.inner
.bounding_box_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_bounding_box_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_bounding_box_stride(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureCurveGeometryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureCurveGeometryDescriptor,
}
impl AccelerationStructureCurveGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureCurveGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::AccelerationStructureCurveGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_count(&self) -> Result<usize, crate::Error> {
self.inner
.control_point_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_control_point_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_stride(&self) -> Result<usize, crate::Error> {
self.inner
.control_point_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_control_point_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn radius_stride(&self) -> Result<usize, crate::Error> {
self.inner.radius_stride().map_err(crate::Error::from_ffi)
}
pub fn set_radius_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_radius_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn segment_control_point_count(&self) -> Result<usize, crate::Error> {
self.inner
.segment_control_point_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_segment_control_point_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_segment_control_point_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn segment_count(&self) -> Result<usize, crate::Error> {
self.inner.segment_count().map_err(crate::Error::from_ffi)
}
pub fn set_segment_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_segment_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner
.control_point_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_control_point_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_basis(&self) -> Result<crate::metal::CurveBasis, crate::Error> {
self.inner.curve_basis().map_err(crate::Error::from_ffi)
}
pub fn set_curve_basis(&self, value: crate::metal::CurveBasis) -> Result<(), crate::Error> {
self.inner
.set_curve_basis(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_end_caps(&self) -> Result<crate::metal::CurveEndCaps, crate::Error> {
self.inner.curve_end_caps().map_err(crate::Error::from_ffi)
}
pub fn set_curve_end_caps(
&self,
value: crate::metal::CurveEndCaps,
) -> Result<(), crate::Error> {
self.inner
.set_curve_end_caps(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_type(&self) -> Result<crate::metal::CurveType, crate::Error> {
self.inner.curve_type().map_err(crate::Error::from_ffi)
}
pub fn set_curve_type(&self, value: crate::metal::CurveType) -> Result<(), crate::Error> {
self.inner
.set_curve_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_type(&self) -> Result<crate::metal::IndexType, crate::Error> {
self.inner.index_type().map_err(crate::Error::from_ffi)
}
pub fn set_index_type(&self, value: crate::metal::IndexType) -> Result<(), crate::Error> {
self.inner
.set_index_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn radius_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner.radius_format().map_err(crate::Error::from_ffi)
}
pub fn set_radius_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_radius_format(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal4::AccelerationStructureDescriptor,
}
impl AccelerationStructureDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::AccelerationStructureDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureGeometryDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal4::AccelerationStructureGeometryDescriptor,
}
impl AccelerationStructureGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::AccelerationStructureGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn allow_duplicate_intersection_function_invocation(
&self,
) -> Result<bool, crate::Error> {
self.inner
.allow_duplicate_intersection_function_invocation()
.map_err(crate::Error::from_ffi)
}
pub fn intersection_function_table_offset(&self) -> Result<usize, crate::Error> {
self.inner
.intersection_function_table_offset()
.map_err(crate::Error::from_ffi)
}
pub fn set_intersection_function_table_offset(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_intersection_function_table_offset(value)
.map_err(crate::Error::from_ffi)
}
pub fn opaque(&self) -> Result<bool, crate::Error> {
self.inner.opaque().map_err(crate::Error::from_ffi)
}
pub fn primitive_data_element_size(&self) -> Result<usize, crate::Error> {
self.inner
.primitive_data_element_size()
.map_err(crate::Error::from_ffi)
}
pub fn set_primitive_data_element_size(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_primitive_data_element_size(value)
.map_err(crate::Error::from_ffi)
}
pub fn primitive_data_stride(&self) -> Result<usize, crate::Error> {
self.inner
.primitive_data_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_primitive_data_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_primitive_data_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn set_allow_duplicate_intersection_function_invocation(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_allow_duplicate_intersection_function_invocation(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_opaque(&self, value: bool) -> Result<(), crate::Error> {
self.inner.set_opaque(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureMotionBoundingBoxGeometryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureMotionBoundingBoxGeometryDescriptor,
}
impl AccelerationStructureMotionBoundingBoxGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureMotionBoundingBoxGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn bounding_box_count(&self) -> Result<usize, crate::Error> {
self.inner
.bounding_box_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_bounding_box_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_bounding_box_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn bounding_box_stride(&self) -> Result<usize, crate::Error> {
self.inner
.bounding_box_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_bounding_box_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_bounding_box_stride(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureMotionCurveGeometryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureMotionCurveGeometryDescriptor,
}
impl AccelerationStructureMotionCurveGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureMotionCurveGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::AccelerationStructureMotionCurveGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_count(&self) -> Result<usize, crate::Error> {
self.inner
.control_point_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_control_point_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_stride(&self) -> Result<usize, crate::Error> {
self.inner
.control_point_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_control_point_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn radius_stride(&self) -> Result<usize, crate::Error> {
self.inner.radius_stride().map_err(crate::Error::from_ffi)
}
pub fn set_radius_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_radius_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn segment_control_point_count(&self) -> Result<usize, crate::Error> {
self.inner
.segment_control_point_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_segment_control_point_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_segment_control_point_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn segment_count(&self) -> Result<usize, crate::Error> {
self.inner.segment_count().map_err(crate::Error::from_ffi)
}
pub fn set_segment_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_segment_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn control_point_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner
.control_point_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_control_point_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_control_point_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_basis(&self) -> Result<crate::metal::CurveBasis, crate::Error> {
self.inner.curve_basis().map_err(crate::Error::from_ffi)
}
pub fn set_curve_basis(&self, value: crate::metal::CurveBasis) -> Result<(), crate::Error> {
self.inner
.set_curve_basis(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_end_caps(&self) -> Result<crate::metal::CurveEndCaps, crate::Error> {
self.inner.curve_end_caps().map_err(crate::Error::from_ffi)
}
pub fn set_curve_end_caps(
&self,
value: crate::metal::CurveEndCaps,
) -> Result<(), crate::Error> {
self.inner
.set_curve_end_caps(value)
.map_err(crate::Error::from_ffi)
}
pub fn curve_type(&self) -> Result<crate::metal::CurveType, crate::Error> {
self.inner.curve_type().map_err(crate::Error::from_ffi)
}
pub fn set_curve_type(&self, value: crate::metal::CurveType) -> Result<(), crate::Error> {
self.inner
.set_curve_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_type(&self) -> Result<crate::metal::IndexType, crate::Error> {
self.inner.index_type().map_err(crate::Error::from_ffi)
}
pub fn set_index_type(&self, value: crate::metal::IndexType) -> Result<(), crate::Error> {
self.inner
.set_index_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn radius_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner.radius_format().map_err(crate::Error::from_ffi)
}
pub fn set_radius_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_radius_format(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureMotionTriangleGeometryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureMotionTriangleGeometryDescriptor,
}
impl AccelerationStructureMotionTriangleGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureMotionTriangleGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::AccelerationStructureMotionTriangleGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn triangle_count(&self) -> Result<usize, crate::Error> {
self.inner.triangle_count().map_err(crate::Error::from_ffi)
}
pub fn set_triangle_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_triangle_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn vertex_stride(&self) -> Result<usize, crate::Error> {
self.inner.vertex_stride().map_err(crate::Error::from_ffi)
}
pub fn set_vertex_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_vertex_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_type(&self) -> Result<crate::metal::IndexType, crate::Error> {
self.inner.index_type().map_err(crate::Error::from_ffi)
}
pub fn set_index_type(&self, value: crate::metal::IndexType) -> Result<(), crate::Error> {
self.inner
.set_index_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn transformation_matrix_layout(
&self,
) -> Result<crate::metal::MatrixLayout, crate::Error> {
self.inner
.transformation_matrix_layout()
.map_err(crate::Error::from_ffi)
}
pub fn set_transformation_matrix_layout(
&self,
value: crate::metal::MatrixLayout,
) -> Result<(), crate::Error> {
self.inner
.set_transformation_matrix_layout(value)
.map_err(crate::Error::from_ffi)
}
pub fn vertex_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner.vertex_format().map_err(crate::Error::from_ffi)
}
pub fn set_vertex_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_vertex_format(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct AccelerationStructureTriangleGeometryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureTriangleGeometryDescriptor,
}
impl AccelerationStructureTriangleGeometryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::AccelerationStructureTriangleGeometryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::AccelerationStructureTriangleGeometryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn triangle_count(&self) -> Result<usize, crate::Error> {
self.inner.triangle_count().map_err(crate::Error::from_ffi)
}
pub fn set_triangle_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_triangle_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn vertex_stride(&self) -> Result<usize, crate::Error> {
self.inner.vertex_stride().map_err(crate::Error::from_ffi)
}
pub fn set_vertex_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_vertex_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn index_type(&self) -> Result<crate::metal::IndexType, crate::Error> {
self.inner.index_type().map_err(crate::Error::from_ffi)
}
pub fn set_index_type(&self, value: crate::metal::IndexType) -> Result<(), crate::Error> {
self.inner
.set_index_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn transformation_matrix_layout(
&self,
) -> Result<crate::metal::MatrixLayout, crate::Error> {
self.inner
.transformation_matrix_layout()
.map_err(crate::Error::from_ffi)
}
pub fn set_transformation_matrix_layout(
&self,
value: crate::metal::MatrixLayout,
) -> Result<(), crate::Error> {
self.inner
.set_transformation_matrix_layout(value)
.map_err(crate::Error::from_ffi)
}
pub fn vertex_format(&self) -> Result<crate::metal::AttributeFormat, crate::Error> {
self.inner.vertex_format().map_err(crate::Error::from_ffi)
}
pub fn set_vertex_format(
&self,
value: crate::metal::AttributeFormat,
) -> Result<(), crate::Error> {
self.inner
.set_vertex_format(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Archive {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::Archive,
}
impl Archive {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::Archive,
) -> Self {
Self { inner }
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ArgumentTable {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::ArgumentTable,
}
impl ArgumentTable {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::ArgumentTable,
) -> Self {
Self { inner }
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ArgumentTableDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::ArgumentTableDescriptor,
}
impl ArgumentTableDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::ArgumentTableDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::ArgumentTableDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn initialize_bindings(&self) -> Result<bool, crate::Error> {
self.inner
.initialize_bindings()
.map_err(crate::Error::from_ffi)
}
pub fn max_buffer_bind_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_buffer_bind_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_buffer_bind_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_buffer_bind_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_sampler_state_bind_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_sampler_state_bind_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_sampler_state_bind_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_sampler_state_bind_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_texture_bind_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_texture_bind_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_texture_bind_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_texture_bind_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_attribute_strides(&self) -> Result<bool, crate::Error> {
self.inner
.support_attribute_strides()
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn set_initialize_bindings(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_initialize_bindings(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_attribute_strides(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_attribute_strides(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct BinaryFunction {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::BinaryFunction,
}
impl BinaryFunction {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::BinaryFunction,
) -> Self {
Self { inner }
}
pub fn function_type(&self) -> Result<crate::metal::FunctionType, crate::Error> {
self.inner.function_type().map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct BinaryFunctionDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::BinaryFunctionDescriptor,
}
impl BinaryFunctionDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::BinaryFunctionDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::BinaryFunctionDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn options(&self) -> Result<crate::metal4::BinaryFunctionOptions, crate::Error> {
self.inner.options().map_err(crate::Error::from_ffi)
}
pub fn set_options(
&self,
value: crate::metal4::BinaryFunctionOptions,
) -> Result<(), crate::Error> {
self.inner
.set_options(value)
.map_err(crate::Error::from_ffi)
}
pub fn function_descriptor(
&self,
) -> Result<Option<crate::metal4::FunctionDescriptor>, crate::Error> {
self.inner
.function_descriptor()
.map(|value| value.map(crate::metal4::FunctionDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_function_descriptor(
&self,
value: Option<&crate::metal4::FunctionDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_function_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
pub fn set_name(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_name(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CommandAllocator {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::CommandAllocator,
}
impl CommandAllocator {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::CommandAllocator,
) -> Self {
Self { inner }
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CommandAllocatorDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::CommandAllocatorDescriptor,
}
impl CommandAllocatorDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::CommandAllocatorDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::CommandAllocatorDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CommandBufferOptions {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::CommandBufferOptions,
}
impl CommandBufferOptions {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::CommandBufferOptions,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::CommandBufferOptions::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn log_state(&self) -> Result<Option<crate::metal::LogState>, crate::Error> {
self.inner
.log_state()
.map(|value| value.map(crate::metal::LogState::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_log_state(
&self,
value: Option<&crate::metal::LogState>,
) -> Result<(), crate::Error> {
self.inner
.set_log_state(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CommandQueue {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::CommandQueue,
}
impl CommandQueue {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::CommandQueue,
) -> Self {
Self { inner }
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CommandQueueDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::CommandQueueDescriptor,
}
impl CommandQueueDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::CommandQueueDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::CommandQueueDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CommitFeedback {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::CommitFeedback,
}
impl CommitFeedback {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::CommitFeedback,
) -> Self {
Self { inner }
}
pub fn gpu_end_time(&self) -> Result<f64, crate::Error> {
self.inner.gpu_end_time().map_err(crate::Error::from_ffi)
}
pub fn gpu_start_time(&self) -> Result<f64, crate::Error> {
self.inner.gpu_start_time().map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CommitOptions {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::CommitOptions,
}
impl CommitOptions {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::CommitOptions,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::CommitOptions::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct Compiler {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::Compiler,
}
impl Compiler {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::Compiler,
) -> Self {
Self { inner }
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn pipeline_data_set_serializer(
&self,
) -> Result<Option<crate::metal4::PipelineDataSetSerializer>, crate::Error> {
self.inner
.pipeline_data_set_serializer()
.map(|value| value.map(crate::metal4::PipelineDataSetSerializer::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CompilerDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::CompilerDescriptor,
}
impl CompilerDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::CompilerDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::CompilerDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn pipeline_data_set_serializer(
&self,
) -> Result<Option<crate::metal4::PipelineDataSetSerializer>, crate::Error> {
self.inner
.pipeline_data_set_serializer()
.map(|value| value.map(crate::metal4::PipelineDataSetSerializer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_pipeline_data_set_serializer(
&self,
value: Option<&crate::metal4::PipelineDataSetSerializer>,
) -> Result<(), crate::Error> {
self.inner
.set_pipeline_data_set_serializer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CompilerTask {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::CompilerTask,
}
impl CompilerTask {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::CompilerTask,
) -> Self {
Self { inner }
}
pub fn status(&self) -> Result<crate::metal4::CompilerTaskStatus, crate::Error> {
self.inner.status().map_err(crate::Error::from_ffi)
}
pub fn compiler(&self) -> Result<Option<crate::metal4::Compiler>, crate::Error> {
self.inner
.compiler()
.map(|value| value.map(crate::metal4::Compiler::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CompilerTaskOptions {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::CompilerTaskOptions,
}
impl CompilerTaskOptions {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::CompilerTaskOptions,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::CompilerTaskOptions::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct ComputePipelineDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::ComputePipelineDescriptor,
}
impl ComputePipelineDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::ComputePipelineDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::ComputePipelineDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn max_total_threads_per_threadgroup(&self) -> Result<usize, crate::Error> {
self.inner
.max_total_threads_per_threadgroup()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_total_threads_per_threadgroup(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_total_threads_per_threadgroup(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_binary_linking(&self) -> Result<bool, crate::Error> {
self.inner
.support_binary_linking()
.map_err(crate::Error::from_ffi)
}
pub fn thread_group_size_is_multiple_of_thread_execution_width(
&self,
) -> Result<bool, crate::Error> {
self.inner
.thread_group_size_is_multiple_of_thread_execution_width()
.map_err(crate::Error::from_ffi)
}
pub fn support_indirect_command_buffers(
&self,
) -> Result<crate::metal4::IndirectCommandBufferSupportState, crate::Error> {
self.inner
.support_indirect_command_buffers()
.map_err(crate::Error::from_ffi)
}
pub fn set_support_indirect_command_buffers(
&self,
value: crate::metal4::IndirectCommandBufferSupportState,
) -> Result<(), crate::Error> {
self.inner
.set_support_indirect_command_buffers(value)
.map_err(crate::Error::from_ffi)
}
pub fn compute_function_descriptor(
&self,
) -> Result<Option<crate::metal4::FunctionDescriptor>, crate::Error> {
self.inner
.compute_function_descriptor()
.map(|value| value.map(crate::metal4::FunctionDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_compute_function_descriptor(
&self,
value: Option<&crate::metal4::FunctionDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_compute_function_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn static_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::StaticLinkingDescriptor>, crate::Error> {
self.inner
.static_linking_descriptor()
.map(|value| value.map(crate::metal4::StaticLinkingDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_static_linking_descriptor(
&self,
value: Option<&crate::metal4::StaticLinkingDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_static_linking_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_support_binary_linking(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_binary_linking(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_thread_group_size_is_multiple_of_thread_execution_width(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_thread_group_size_is_multiple_of_thread_execution_width(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct CounterHeapDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::CounterHeapDescriptor,
}
impl CounterHeapDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::CounterHeapDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::CounterHeapDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn count(&self) -> Result<usize, crate::Error> {
self.inner.count().map_err(crate::Error::from_ffi)
}
pub fn set_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner.set_count(value).map_err(crate::Error::from_ffi)
}
pub fn r#type(&self) -> Result<crate::metal4::CounterHeapType, crate::Error> {
self.inner.r#type().map_err(crate::Error::from_ffi)
}
pub fn set_type(&self, value: crate::metal4::CounterHeapType) -> Result<(), crate::Error> {
self.inner.set_type(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FunctionDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::FunctionDescriptor,
}
impl FunctionDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::FunctionDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::FunctionDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct IndirectInstanceAccelerationStructureDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::IndirectInstanceAccelerationStructureDescriptor,
}
impl IndirectInstanceAccelerationStructureDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::IndirectInstanceAccelerationStructureDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::IndirectInstanceAccelerationStructureDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_stride(&self) -> Result<usize, crate::Error> {
self.inner
.instance_descriptor_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_instance_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_instance_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_instance_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_instance_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_motion_transform_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_motion_transform_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_motion_transform_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_motion_transform_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_stride(&self) -> Result<usize, crate::Error> {
self.inner
.motion_transform_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_type(
&self,
) -> Result<crate::metal::AccelerationStructureInstanceDescriptorType, crate::Error>
{
self.inner
.instance_descriptor_type()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_type(
&self,
value: crate::metal::AccelerationStructureInstanceDescriptorType,
) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_transformation_matrix_layout(
&self,
) -> Result<crate::metal::MatrixLayout, crate::Error> {
self.inner
.instance_transformation_matrix_layout()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_transformation_matrix_layout(
&self,
value: crate::metal::MatrixLayout,
) -> Result<(), crate::Error> {
self.inner
.set_instance_transformation_matrix_layout(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_type(&self) -> Result<crate::metal::TransformType, crate::Error> {
self.inner
.motion_transform_type()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_type(
&self,
value: crate::metal::TransformType,
) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_type(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct InstanceAccelerationStructureDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal4::InstanceAccelerationStructureDescriptor,
}
impl InstanceAccelerationStructureDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::InstanceAccelerationStructureDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::InstanceAccelerationStructureDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn instance_count(&self) -> Result<usize, crate::Error> {
self.inner.instance_count().map_err(crate::Error::from_ffi)
}
pub fn set_instance_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_instance_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_stride(&self) -> Result<usize, crate::Error> {
self.inner
.instance_descriptor_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_count(&self) -> Result<usize, crate::Error> {
self.inner
.motion_transform_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_stride(&self) -> Result<usize, crate::Error> {
self.inner
.motion_transform_stride()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_stride(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_stride(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_descriptor_type(
&self,
) -> Result<crate::metal::AccelerationStructureInstanceDescriptorType, crate::Error>
{
self.inner
.instance_descriptor_type()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_descriptor_type(
&self,
value: crate::metal::AccelerationStructureInstanceDescriptorType,
) -> Result<(), crate::Error> {
self.inner
.set_instance_descriptor_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn instance_transformation_matrix_layout(
&self,
) -> Result<crate::metal::MatrixLayout, crate::Error> {
self.inner
.instance_transformation_matrix_layout()
.map_err(crate::Error::from_ffi)
}
pub fn set_instance_transformation_matrix_layout(
&self,
value: crate::metal::MatrixLayout,
) -> Result<(), crate::Error> {
self.inner
.set_instance_transformation_matrix_layout(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_transform_type(&self) -> Result<crate::metal::TransformType, crate::Error> {
self.inner
.motion_transform_type()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_transform_type(
&self,
value: crate::metal::TransformType,
) -> Result<(), crate::Error> {
self.inner
.set_motion_transform_type(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct LibraryDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::LibraryDescriptor,
}
impl LibraryDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::LibraryDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::LibraryDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
pub fn set_name(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_name(value).map_err(crate::Error::from_ffi)
}
pub fn options(&self) -> Result<Option<crate::metal::CompileOptions>, crate::Error> {
self.inner
.options()
.map(|value| value.map(crate::metal::CompileOptions::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_options(
&self,
value: Option<&crate::metal::CompileOptions>,
) -> Result<(), crate::Error> {
self.inner
.set_options(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn source(&self) -> Result<Option<String>, crate::Error> {
self.inner.source().map_err(crate::Error::from_ffi)
}
pub fn set_source(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_source(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct LibraryFunctionDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::LibraryFunctionDescriptor,
}
impl LibraryFunctionDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::LibraryFunctionDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::LibraryFunctionDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn library(&self) -> Result<Option<crate::metal::Library>, crate::Error> {
self.inner
.library()
.map(|value| value.map(crate::metal::Library::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_library(
&self,
value: Option<&crate::metal::Library>,
) -> Result<(), crate::Error> {
self.inner
.set_library(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn name(&self) -> Result<Option<String>, crate::Error> {
self.inner.name().map_err(crate::Error::from_ffi)
}
pub fn set_name(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_name(value).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct MachineLearningPipelineDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal4::MachineLearningPipelineDescriptor,
}
impl MachineLearningPipelineDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::MachineLearningPipelineDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::MachineLearningPipelineDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn machine_learning_function_descriptor(
&self,
) -> Result<Option<crate::metal4::FunctionDescriptor>, crate::Error> {
self.inner
.machine_learning_function_descriptor()
.map(|value| value.map(crate::metal4::FunctionDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_machine_learning_function_descriptor(
&self,
value: Option<&crate::metal4::FunctionDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_machine_learning_function_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct MachineLearningPipelineReflection {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal4::MachineLearningPipelineReflection,
}
impl MachineLearningPipelineReflection {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::MachineLearningPipelineReflection,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::MachineLearningPipelineReflection::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct MachineLearningPipelineState {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::MachineLearningPipelineState,
}
impl MachineLearningPipelineState {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::MachineLearningPipelineState,
) -> Self {
Self { inner }
}
pub fn intermediates_heap_size(&self) -> Result<usize, crate::Error> {
self.inner
.intermediates_heap_size()
.map_err(crate::Error::from_ffi)
}
pub fn device(&self) -> Result<Option<crate::metal::Device>, crate::Error> {
self.inner
.device()
.map(|value| value.map(crate::metal::Device::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn reflection(
&self,
) -> Result<Option<crate::metal4::MachineLearningPipelineReflection>, crate::Error>
{
self.inner
.reflection()
.map(|value| value.map(crate::metal4::MachineLearningPipelineReflection::from_ffi))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct MeshRenderPipelineDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::MeshRenderPipelineDescriptor,
}
impl MeshRenderPipelineDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::MeshRenderPipelineDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::MeshRenderPipelineDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn is_rasterization_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_rasterization_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn max_total_threadgroups_per_mesh_grid(&self) -> Result<usize, crate::Error> {
self.inner
.max_total_threadgroups_per_mesh_grid()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_total_threadgroups_per_mesh_grid(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_total_threadgroups_per_mesh_grid(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_total_threads_per_mesh_threadgroup(&self) -> Result<usize, crate::Error> {
self.inner
.max_total_threads_per_mesh_threadgroup()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_total_threads_per_mesh_threadgroup(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_total_threads_per_mesh_threadgroup(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_total_threads_per_object_threadgroup(&self) -> Result<usize, crate::Error> {
self.inner
.max_total_threads_per_object_threadgroup()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_total_threads_per_object_threadgroup(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_total_threads_per_object_threadgroup(value)
.map_err(crate::Error::from_ffi)
}
pub fn max_vertex_amplification_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_vertex_amplification_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_vertex_amplification_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_vertex_amplification_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn mesh_threadgroup_size_is_multiple_of_thread_execution_width(
&self,
) -> Result<bool, crate::Error> {
self.inner
.mesh_threadgroup_size_is_multiple_of_thread_execution_width()
.map_err(crate::Error::from_ffi)
}
pub fn object_threadgroup_size_is_multiple_of_thread_execution_width(
&self,
) -> Result<bool, crate::Error> {
self.inner
.object_threadgroup_size_is_multiple_of_thread_execution_width()
.map_err(crate::Error::from_ffi)
}
pub fn payload_memory_length(&self) -> Result<usize, crate::Error> {
self.inner
.payload_memory_length()
.map_err(crate::Error::from_ffi)
}
pub fn set_payload_memory_length(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_payload_memory_length(value)
.map_err(crate::Error::from_ffi)
}
pub fn raster_sample_count(&self) -> Result<usize, crate::Error> {
self.inner
.raster_sample_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_raster_sample_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_raster_sample_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_fragment_binary_linking(&self) -> Result<bool, crate::Error> {
self.inner
.support_fragment_binary_linking()
.map_err(crate::Error::from_ffi)
}
pub fn support_mesh_binary_linking(&self) -> Result<bool, crate::Error> {
self.inner
.support_mesh_binary_linking()
.map_err(crate::Error::from_ffi)
}
pub fn support_object_binary_linking(&self) -> Result<bool, crate::Error> {
self.inner
.support_object_binary_linking()
.map_err(crate::Error::from_ffi)
}
pub fn alpha_to_coverage_state(
&self,
) -> Result<crate::metal4::AlphaToCoverageState, crate::Error> {
self.inner
.alpha_to_coverage_state()
.map_err(crate::Error::from_ffi)
}
pub fn set_alpha_to_coverage_state(
&self,
value: crate::metal4::AlphaToCoverageState,
) -> Result<(), crate::Error> {
self.inner
.set_alpha_to_coverage_state(value)
.map_err(crate::Error::from_ffi)
}
pub fn alpha_to_one_state(&self) -> Result<crate::metal4::AlphaToOneState, crate::Error> {
self.inner
.alpha_to_one_state()
.map_err(crate::Error::from_ffi)
}
pub fn set_alpha_to_one_state(
&self,
value: crate::metal4::AlphaToOneState,
) -> Result<(), crate::Error> {
self.inner
.set_alpha_to_one_state(value)
.map_err(crate::Error::from_ffi)
}
pub fn color_attachment_mapping_state(
&self,
) -> Result<crate::metal4::LogicalToPhysicalColorAttachmentMappingState, crate::Error>
{
self.inner
.color_attachment_mapping_state()
.map_err(crate::Error::from_ffi)
}
pub fn set_color_attachment_mapping_state(
&self,
value: crate::metal4::LogicalToPhysicalColorAttachmentMappingState,
) -> Result<(), crate::Error> {
self.inner
.set_color_attachment_mapping_state(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_indirect_command_buffers(
&self,
) -> Result<crate::metal4::IndirectCommandBufferSupportState, crate::Error> {
self.inner
.support_indirect_command_buffers()
.map_err(crate::Error::from_ffi)
}
pub fn set_support_indirect_command_buffers(
&self,
value: crate::metal4::IndirectCommandBufferSupportState,
) -> Result<(), crate::Error> {
self.inner
.set_support_indirect_command_buffers(value)
.map_err(crate::Error::from_ffi)
}
pub fn color_attachments(
&self,
) -> Result<Option<crate::metal4::RenderPipelineColorAttachmentDescriptorArray>, crate::Error>
{
self.inner
.color_attachments()
.map(|value| {
value.map(crate::metal4::RenderPipelineColorAttachmentDescriptorArray::from_ffi)
})
.map_err(crate::Error::from_ffi)
}
pub fn fragment_function_descriptor(
&self,
) -> Result<Option<crate::metal4::FunctionDescriptor>, crate::Error> {
self.inner
.fragment_function_descriptor()
.map(|value| value.map(crate::metal4::FunctionDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_fragment_function_descriptor(
&self,
value: Option<&crate::metal4::FunctionDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_fragment_function_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn fragment_static_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::StaticLinkingDescriptor>, crate::Error> {
self.inner
.fragment_static_linking_descriptor()
.map(|value| value.map(crate::metal4::StaticLinkingDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_fragment_static_linking_descriptor(
&self,
value: Option<&crate::metal4::StaticLinkingDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_fragment_static_linking_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn mesh_function_descriptor(
&self,
) -> Result<Option<crate::metal4::FunctionDescriptor>, crate::Error> {
self.inner
.mesh_function_descriptor()
.map(|value| value.map(crate::metal4::FunctionDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_mesh_function_descriptor(
&self,
value: Option<&crate::metal4::FunctionDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_mesh_function_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn mesh_static_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::StaticLinkingDescriptor>, crate::Error> {
self.inner
.mesh_static_linking_descriptor()
.map(|value| value.map(crate::metal4::StaticLinkingDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_mesh_static_linking_descriptor(
&self,
value: Option<&crate::metal4::StaticLinkingDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_mesh_static_linking_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn object_function_descriptor(
&self,
) -> Result<Option<crate::metal4::FunctionDescriptor>, crate::Error> {
self.inner
.object_function_descriptor()
.map(|value| value.map(crate::metal4::FunctionDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_object_function_descriptor(
&self,
value: Option<&crate::metal4::FunctionDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_object_function_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn object_static_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::StaticLinkingDescriptor>, crate::Error> {
self.inner
.object_static_linking_descriptor()
.map(|value| value.map(crate::metal4::StaticLinkingDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_object_static_linking_descriptor(
&self,
value: Option<&crate::metal4::StaticLinkingDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_object_static_linking_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_mesh_threadgroup_size_is_multiple_of_thread_execution_width(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_mesh_threadgroup_size_is_multiple_of_thread_execution_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_object_threadgroup_size_is_multiple_of_thread_execution_width(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_object_threadgroup_size_is_multiple_of_thread_execution_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_rasterization_enabled(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_rasterization_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_fragment_binary_linking(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_fragment_binary_linking(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_mesh_binary_linking(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_mesh_binary_linking(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_object_binary_linking(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_object_binary_linking(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct PipelineDataSetSerializer {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::PipelineDataSetSerializer,
}
impl PipelineDataSetSerializer {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::PipelineDataSetSerializer,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct PipelineDataSetSerializerDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal4::PipelineDataSetSerializerDescriptor,
}
impl PipelineDataSetSerializerDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::PipelineDataSetSerializerDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::PipelineDataSetSerializerDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn configuration(
&self,
) -> Result<crate::metal4::PipelineDataSetSerializerConfiguration, crate::Error> {
self.inner.configuration().map_err(crate::Error::from_ffi)
}
pub fn set_configuration(
&self,
value: crate::metal4::PipelineDataSetSerializerConfiguration,
) -> Result<(), crate::Error> {
self.inner
.set_configuration(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct PipelineDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::PipelineDescriptor,
}
impl PipelineDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::PipelineDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::PipelineDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn label(&self) -> Result<Option<String>, crate::Error> {
self.inner.label().map_err(crate::Error::from_ffi)
}
pub fn set_label(&self, value: &str) -> Result<(), crate::Error> {
self.inner.set_label(value).map_err(crate::Error::from_ffi)
}
pub fn options(&self) -> Result<Option<crate::metal4::PipelineOptions>, crate::Error> {
self.inner
.options()
.map(|value| value.map(crate::metal4::PipelineOptions::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_options(
&self,
value: Option<&crate::metal4::PipelineOptions>,
) -> Result<(), crate::Error> {
self.inner
.set_options(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct PipelineOptions {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::PipelineOptions,
}
impl PipelineOptions {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::PipelineOptions,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::PipelineOptions::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn shader_reflection(&self) -> Result<crate::metal4::ShaderReflection, crate::Error> {
self.inner
.shader_reflection()
.map_err(crate::Error::from_ffi)
}
pub fn set_shader_reflection(
&self,
value: crate::metal4::ShaderReflection,
) -> Result<(), crate::Error> {
self.inner
.set_shader_reflection(value)
.map_err(crate::Error::from_ffi)
}
pub fn shader_validation(&self) -> Result<crate::metal::ShaderValidation, crate::Error> {
self.inner
.shader_validation()
.map_err(crate::Error::from_ffi)
}
pub fn set_shader_validation(
&self,
value: crate::metal::ShaderValidation,
) -> Result<(), crate::Error> {
self.inner
.set_shader_validation(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct PipelineStageDynamicLinkingDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal4::PipelineStageDynamicLinkingDescriptor,
}
impl PipelineStageDynamicLinkingDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::PipelineStageDynamicLinkingDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::PipelineStageDynamicLinkingDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn max_call_stack_depth(&self) -> Result<usize, crate::Error> {
self.inner
.max_call_stack_depth()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_call_stack_depth(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_call_stack_depth(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct PrimitiveAccelerationStructureDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal4::PrimitiveAccelerationStructureDescriptor,
}
impl PrimitiveAccelerationStructureDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::PrimitiveAccelerationStructureDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::PrimitiveAccelerationStructureDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn motion_end_time(&self) -> Result<f32, crate::Error> {
self.inner.motion_end_time().map_err(crate::Error::from_ffi)
}
pub fn set_motion_end_time(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_motion_end_time(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_keyframe_count(&self) -> Result<usize, crate::Error> {
self.inner
.motion_keyframe_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_keyframe_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_keyframe_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_start_time(&self) -> Result<f32, crate::Error> {
self.inner
.motion_start_time()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_start_time(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_motion_start_time(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_end_border_mode(
&self,
) -> Result<crate::metal::MotionBorderMode, crate::Error> {
self.inner
.motion_end_border_mode()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_end_border_mode(
&self,
value: crate::metal::MotionBorderMode,
) -> Result<(), crate::Error> {
self.inner
.set_motion_end_border_mode(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_start_border_mode(
&self,
) -> Result<crate::metal::MotionBorderMode, crate::Error> {
self.inner
.motion_start_border_mode()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_start_border_mode(
&self,
value: crate::metal::MotionBorderMode,
) -> Result<(), crate::Error> {
self.inner
.set_motion_start_border_mode(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPassDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::RenderPassDescriptor,
}
impl RenderPassDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::RenderPassDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::RenderPassDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn default_raster_sample_count(&self) -> Result<usize, crate::Error> {
self.inner
.default_raster_sample_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_default_raster_sample_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_default_raster_sample_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn imageblock_sample_length(&self) -> Result<usize, crate::Error> {
self.inner
.imageblock_sample_length()
.map_err(crate::Error::from_ffi)
}
pub fn set_imageblock_sample_length(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_imageblock_sample_length(value)
.map_err(crate::Error::from_ffi)
}
pub fn render_target_array_length(&self) -> Result<usize, crate::Error> {
self.inner
.render_target_array_length()
.map_err(crate::Error::from_ffi)
}
pub fn set_render_target_array_length(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_render_target_array_length(value)
.map_err(crate::Error::from_ffi)
}
pub fn render_target_height(&self) -> Result<usize, crate::Error> {
self.inner
.render_target_height()
.map_err(crate::Error::from_ffi)
}
pub fn set_render_target_height(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_render_target_height(value)
.map_err(crate::Error::from_ffi)
}
pub fn render_target_width(&self) -> Result<usize, crate::Error> {
self.inner
.render_target_width()
.map_err(crate::Error::from_ffi)
}
pub fn set_render_target_width(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_render_target_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_color_attachment_mapping(&self) -> Result<bool, crate::Error> {
self.inner
.support_color_attachment_mapping()
.map_err(crate::Error::from_ffi)
}
pub fn threadgroup_memory_length(&self) -> Result<usize, crate::Error> {
self.inner
.threadgroup_memory_length()
.map_err(crate::Error::from_ffi)
}
pub fn set_threadgroup_memory_length(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_threadgroup_memory_length(value)
.map_err(crate::Error::from_ffi)
}
pub fn tile_height(&self) -> Result<usize, crate::Error> {
self.inner.tile_height().map_err(crate::Error::from_ffi)
}
pub fn set_tile_height(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_tile_height(value)
.map_err(crate::Error::from_ffi)
}
pub fn tile_width(&self) -> Result<usize, crate::Error> {
self.inner.tile_width().map_err(crate::Error::from_ffi)
}
pub fn set_tile_width(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_tile_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn visibility_result_type(
&self,
) -> Result<crate::metal::VisibilityResultType, crate::Error> {
self.inner
.visibility_result_type()
.map_err(crate::Error::from_ffi)
}
pub fn set_visibility_result_type(
&self,
value: crate::metal::VisibilityResultType,
) -> Result<(), crate::Error> {
self.inner
.set_visibility_result_type(value)
.map_err(crate::Error::from_ffi)
}
pub fn color_attachments(
&self,
) -> Result<Option<crate::metal::RenderPassColorAttachmentDescriptorArray>, crate::Error>
{
self.inner
.color_attachments()
.map(|value| {
value.map(crate::metal::RenderPassColorAttachmentDescriptorArray::from_ffi)
})
.map_err(crate::Error::from_ffi)
}
pub fn depth_attachment(
&self,
) -> Result<Option<crate::metal::RenderPassDepthAttachmentDescriptor>, crate::Error>
{
self.inner
.depth_attachment()
.map(|value| value.map(crate::metal::RenderPassDepthAttachmentDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_attachment(
&self,
value: Option<&crate::metal::RenderPassDepthAttachmentDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_depth_attachment(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn rasterization_rate_map(
&self,
) -> Result<Option<crate::metal::RasterizationRateMap>, crate::Error> {
self.inner
.rasterization_rate_map()
.map(|value| value.map(crate::metal::RasterizationRateMap::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_rasterization_rate_map(
&self,
value: Option<&crate::metal::RasterizationRateMap>,
) -> Result<(), crate::Error> {
self.inner
.set_rasterization_rate_map(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn stencil_attachment(
&self,
) -> Result<Option<crate::metal::RenderPassStencilAttachmentDescriptor>, crate::Error>
{
self.inner
.stencil_attachment()
.map(|value| {
value.map(crate::metal::RenderPassStencilAttachmentDescriptor::from_ffi)
})
.map_err(crate::Error::from_ffi)
}
pub fn set_stencil_attachment(
&self,
value: Option<&crate::metal::RenderPassStencilAttachmentDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_stencil_attachment(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn visibility_result_buffer(
&self,
) -> Result<Option<crate::metal::Buffer>, crate::Error> {
self.inner
.visibility_result_buffer()
.map(|value| value.map(crate::metal::Buffer::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_visibility_result_buffer(
&self,
value: Option<&crate::metal::Buffer>,
) -> Result<(), crate::Error> {
self.inner
.set_visibility_result_buffer(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_support_color_attachment_mapping(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_support_color_attachment_mapping(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPipelineBinaryFunctionsDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal4::RenderPipelineBinaryFunctionsDescriptor,
}
impl RenderPipelineBinaryFunctionsDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::RenderPipelineBinaryFunctionsDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::RenderPipelineBinaryFunctionsDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPipelineColorAttachmentDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal4::RenderPipelineColorAttachmentDescriptor,
}
impl RenderPipelineColorAttachmentDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::RenderPipelineColorAttachmentDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::RenderPipelineColorAttachmentDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn alpha_blend_operation(&self) -> Result<crate::metal::BlendOperation, crate::Error> {
self.inner
.alpha_blend_operation()
.map_err(crate::Error::from_ffi)
}
pub fn set_alpha_blend_operation(
&self,
value: crate::metal::BlendOperation,
) -> Result<(), crate::Error> {
self.inner
.set_alpha_blend_operation(value)
.map_err(crate::Error::from_ffi)
}
pub fn blending_state(&self) -> Result<crate::metal4::BlendState, crate::Error> {
self.inner.blending_state().map_err(crate::Error::from_ffi)
}
pub fn set_blending_state(
&self,
value: crate::metal4::BlendState,
) -> Result<(), crate::Error> {
self.inner
.set_blending_state(value)
.map_err(crate::Error::from_ffi)
}
pub fn destination_alpha_blend_factor(
&self,
) -> Result<crate::metal::BlendFactor, crate::Error> {
self.inner
.destination_alpha_blend_factor()
.map_err(crate::Error::from_ffi)
}
pub fn set_destination_alpha_blend_factor(
&self,
value: crate::metal::BlendFactor,
) -> Result<(), crate::Error> {
self.inner
.set_destination_alpha_blend_factor(value)
.map_err(crate::Error::from_ffi)
}
pub fn destination_rgb_blend_factor(
&self,
) -> Result<crate::metal::BlendFactor, crate::Error> {
self.inner
.destination_rgb_blend_factor()
.map_err(crate::Error::from_ffi)
}
pub fn set_destination_rgb_blend_factor(
&self,
value: crate::metal::BlendFactor,
) -> Result<(), crate::Error> {
self.inner
.set_destination_rgb_blend_factor(value)
.map_err(crate::Error::from_ffi)
}
pub fn pixel_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner.pixel_format().map_err(crate::Error::from_ffi)
}
pub fn set_pixel_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_pixel_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn rgb_blend_operation(&self) -> Result<crate::metal::BlendOperation, crate::Error> {
self.inner
.rgb_blend_operation()
.map_err(crate::Error::from_ffi)
}
pub fn set_rgb_blend_operation(
&self,
value: crate::metal::BlendOperation,
) -> Result<(), crate::Error> {
self.inner
.set_rgb_blend_operation(value)
.map_err(crate::Error::from_ffi)
}
pub fn source_alpha_blend_factor(&self) -> Result<crate::metal::BlendFactor, crate::Error> {
self.inner
.source_alpha_blend_factor()
.map_err(crate::Error::from_ffi)
}
pub fn set_source_alpha_blend_factor(
&self,
value: crate::metal::BlendFactor,
) -> Result<(), crate::Error> {
self.inner
.set_source_alpha_blend_factor(value)
.map_err(crate::Error::from_ffi)
}
pub fn source_rgb_blend_factor(&self) -> Result<crate::metal::BlendFactor, crate::Error> {
self.inner
.source_rgb_blend_factor()
.map_err(crate::Error::from_ffi)
}
pub fn set_source_rgb_blend_factor(
&self,
value: crate::metal::BlendFactor,
) -> Result<(), crate::Error> {
self.inner
.set_source_rgb_blend_factor(value)
.map_err(crate::Error::from_ffi)
}
pub fn write_mask(&self) -> Result<crate::metal::ColorWriteMask, crate::Error> {
self.inner.write_mask().map_err(crate::Error::from_ffi)
}
pub fn set_write_mask(
&self,
value: crate::metal::ColorWriteMask,
) -> Result<(), crate::Error> {
self.inner
.set_write_mask(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPipelineColorAttachmentDescriptorArray {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::RenderPipelineColorAttachmentDescriptorArray,
}
impl RenderPipelineColorAttachmentDescriptorArray {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::RenderPipelineColorAttachmentDescriptorArray,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::RenderPipelineColorAttachmentDescriptorArray::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPipelineDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::RenderPipelineDescriptor,
}
impl RenderPipelineDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::RenderPipelineDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::RenderPipelineDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn is_rasterization_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_rasterization_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn max_vertex_amplification_count(&self) -> Result<usize, crate::Error> {
self.inner
.max_vertex_amplification_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_vertex_amplification_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_max_vertex_amplification_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn raster_sample_count(&self) -> Result<usize, crate::Error> {
self.inner
.raster_sample_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_raster_sample_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_raster_sample_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_fragment_binary_linking(&self) -> Result<bool, crate::Error> {
self.inner
.support_fragment_binary_linking()
.map_err(crate::Error::from_ffi)
}
pub fn support_vertex_binary_linking(&self) -> Result<bool, crate::Error> {
self.inner
.support_vertex_binary_linking()
.map_err(crate::Error::from_ffi)
}
pub fn alpha_to_coverage_state(
&self,
) -> Result<crate::metal4::AlphaToCoverageState, crate::Error> {
self.inner
.alpha_to_coverage_state()
.map_err(crate::Error::from_ffi)
}
pub fn set_alpha_to_coverage_state(
&self,
value: crate::metal4::AlphaToCoverageState,
) -> Result<(), crate::Error> {
self.inner
.set_alpha_to_coverage_state(value)
.map_err(crate::Error::from_ffi)
}
pub fn alpha_to_one_state(&self) -> Result<crate::metal4::AlphaToOneState, crate::Error> {
self.inner
.alpha_to_one_state()
.map_err(crate::Error::from_ffi)
}
pub fn set_alpha_to_one_state(
&self,
value: crate::metal4::AlphaToOneState,
) -> Result<(), crate::Error> {
self.inner
.set_alpha_to_one_state(value)
.map_err(crate::Error::from_ffi)
}
pub fn color_attachment_mapping_state(
&self,
) -> Result<crate::metal4::LogicalToPhysicalColorAttachmentMappingState, crate::Error>
{
self.inner
.color_attachment_mapping_state()
.map_err(crate::Error::from_ffi)
}
pub fn set_color_attachment_mapping_state(
&self,
value: crate::metal4::LogicalToPhysicalColorAttachmentMappingState,
) -> Result<(), crate::Error> {
self.inner
.set_color_attachment_mapping_state(value)
.map_err(crate::Error::from_ffi)
}
pub fn input_primitive_topology(
&self,
) -> Result<crate::metal::PrimitiveTopologyClass, crate::Error> {
self.inner
.input_primitive_topology()
.map_err(crate::Error::from_ffi)
}
pub fn set_input_primitive_topology(
&self,
value: crate::metal::PrimitiveTopologyClass,
) -> Result<(), crate::Error> {
self.inner
.set_input_primitive_topology(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_indirect_command_buffers(
&self,
) -> Result<crate::metal4::IndirectCommandBufferSupportState, crate::Error> {
self.inner
.support_indirect_command_buffers()
.map_err(crate::Error::from_ffi)
}
pub fn set_support_indirect_command_buffers(
&self,
value: crate::metal4::IndirectCommandBufferSupportState,
) -> Result<(), crate::Error> {
self.inner
.set_support_indirect_command_buffers(value)
.map_err(crate::Error::from_ffi)
}
pub fn color_attachments(
&self,
) -> Result<Option<crate::metal4::RenderPipelineColorAttachmentDescriptorArray>, crate::Error>
{
self.inner
.color_attachments()
.map(|value| {
value.map(crate::metal4::RenderPipelineColorAttachmentDescriptorArray::from_ffi)
})
.map_err(crate::Error::from_ffi)
}
pub fn fragment_function_descriptor(
&self,
) -> Result<Option<crate::metal4::FunctionDescriptor>, crate::Error> {
self.inner
.fragment_function_descriptor()
.map(|value| value.map(crate::metal4::FunctionDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_fragment_function_descriptor(
&self,
value: Option<&crate::metal4::FunctionDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_fragment_function_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn fragment_static_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::StaticLinkingDescriptor>, crate::Error> {
self.inner
.fragment_static_linking_descriptor()
.map(|value| value.map(crate::metal4::StaticLinkingDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_fragment_static_linking_descriptor(
&self,
value: Option<&crate::metal4::StaticLinkingDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_fragment_static_linking_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn vertex_descriptor(
&self,
) -> Result<Option<crate::metal::VertexDescriptor>, crate::Error> {
self.inner
.vertex_descriptor()
.map(|value| value.map(crate::metal::VertexDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_vertex_descriptor(
&self,
value: Option<&crate::metal::VertexDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_vertex_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn vertex_function_descriptor(
&self,
) -> Result<Option<crate::metal4::FunctionDescriptor>, crate::Error> {
self.inner
.vertex_function_descriptor()
.map(|value| value.map(crate::metal4::FunctionDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_vertex_function_descriptor(
&self,
value: Option<&crate::metal4::FunctionDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_vertex_function_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn vertex_static_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::StaticLinkingDescriptor>, crate::Error> {
self.inner
.vertex_static_linking_descriptor()
.map(|value| value.map(crate::metal4::StaticLinkingDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_vertex_static_linking_descriptor(
&self,
value: Option<&crate::metal4::StaticLinkingDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_vertex_static_linking_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_rasterization_enabled(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_rasterization_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_fragment_binary_linking(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_fragment_binary_linking(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_support_vertex_binary_linking(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_vertex_binary_linking(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct RenderPipelineDynamicLinkingDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal4::RenderPipelineDynamicLinkingDescriptor,
}
impl RenderPipelineDynamicLinkingDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::RenderPipelineDynamicLinkingDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::RenderPipelineDynamicLinkingDescriptor::new(
)
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn fragment_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::PipelineStageDynamicLinkingDescriptor>, crate::Error>
{
self.inner
.fragment_linking_descriptor()
.map(|value| {
value.map(crate::metal4::PipelineStageDynamicLinkingDescriptor::from_ffi)
})
.map_err(crate::Error::from_ffi)
}
pub fn mesh_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::PipelineStageDynamicLinkingDescriptor>, crate::Error>
{
self.inner
.mesh_linking_descriptor()
.map(|value| {
value.map(crate::metal4::PipelineStageDynamicLinkingDescriptor::from_ffi)
})
.map_err(crate::Error::from_ffi)
}
pub fn object_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::PipelineStageDynamicLinkingDescriptor>, crate::Error>
{
self.inner
.object_linking_descriptor()
.map(|value| {
value.map(crate::metal4::PipelineStageDynamicLinkingDescriptor::from_ffi)
})
.map_err(crate::Error::from_ffi)
}
pub fn tile_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::PipelineStageDynamicLinkingDescriptor>, crate::Error>
{
self.inner
.tile_linking_descriptor()
.map(|value| {
value.map(crate::metal4::PipelineStageDynamicLinkingDescriptor::from_ffi)
})
.map_err(crate::Error::from_ffi)
}
pub fn vertex_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::PipelineStageDynamicLinkingDescriptor>, crate::Error>
{
self.inner
.vertex_linking_descriptor()
.map(|value| {
value.map(crate::metal4::PipelineStageDynamicLinkingDescriptor::from_ffi)
})
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct SpecializedFunctionDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::SpecializedFunctionDescriptor,
}
impl SpecializedFunctionDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::SpecializedFunctionDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::SpecializedFunctionDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn constant_values(
&self,
) -> Result<Option<crate::metal::FunctionConstantValues>, crate::Error> {
self.inner
.constant_values()
.map(|value| value.map(crate::metal::FunctionConstantValues::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_constant_values(
&self,
value: Option<&crate::metal::FunctionConstantValues>,
) -> Result<(), crate::Error> {
self.inner
.set_constant_values(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn function_descriptor(
&self,
) -> Result<Option<crate::metal4::FunctionDescriptor>, crate::Error> {
self.inner
.function_descriptor()
.map(|value| value.map(crate::metal4::FunctionDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_function_descriptor(
&self,
value: Option<&crate::metal4::FunctionDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_function_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn specialized_name(&self) -> Result<Option<String>, crate::Error> {
self.inner
.specialized_name()
.map_err(crate::Error::from_ffi)
}
pub fn set_specialized_name(&self, value: &str) -> Result<(), crate::Error> {
self.inner
.set_specialized_name(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct StaticLinkingDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::StaticLinkingDescriptor,
}
impl StaticLinkingDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::StaticLinkingDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::StaticLinkingDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct StitchedFunctionDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::StitchedFunctionDescriptor,
}
impl StitchedFunctionDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::StitchedFunctionDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::StitchedFunctionDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn function_graph(
&self,
) -> Result<Option<crate::metal::FunctionStitchingGraph>, crate::Error> {
self.inner
.function_graph()
.map(|value| value.map(crate::metal::FunctionStitchingGraph::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_function_graph(
&self,
value: Option<&crate::metal::FunctionStitchingGraph>,
) -> Result<(), crate::Error> {
self.inner
.set_function_graph(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TileRenderPipelineDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4::TileRenderPipelineDescriptor,
}
impl TileRenderPipelineDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4::TileRenderPipelineDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal4::TileRenderPipelineDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn max_total_threads_per_threadgroup(&self) -> Result<usize, crate::Error> {
self.inner
.max_total_threads_per_threadgroup()
.map_err(crate::Error::from_ffi)
}
pub fn set_max_total_threads_per_threadgroup(
&self,
value: usize,
) -> Result<(), crate::Error> {
self.inner
.set_max_total_threads_per_threadgroup(value)
.map_err(crate::Error::from_ffi)
}
pub fn raster_sample_count(&self) -> Result<usize, crate::Error> {
self.inner
.raster_sample_count()
.map_err(crate::Error::from_ffi)
}
pub fn set_raster_sample_count(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_raster_sample_count(value)
.map_err(crate::Error::from_ffi)
}
pub fn support_binary_linking(&self) -> Result<bool, crate::Error> {
self.inner
.support_binary_linking()
.map_err(crate::Error::from_ffi)
}
pub fn threadgroup_size_matches_tile_size(&self) -> Result<bool, crate::Error> {
self.inner
.threadgroup_size_matches_tile_size()
.map_err(crate::Error::from_ffi)
}
pub fn color_attachments(
&self,
) -> Result<
Option<crate::metal::TileRenderPipelineColorAttachmentDescriptorArray>,
crate::Error,
> {
self.inner
.color_attachments()
.map(|value| {
value.map(
crate::metal::TileRenderPipelineColorAttachmentDescriptorArray::from_ffi,
)
})
.map_err(crate::Error::from_ffi)
}
pub fn static_linking_descriptor(
&self,
) -> Result<Option<crate::metal4::StaticLinkingDescriptor>, crate::Error> {
self.inner
.static_linking_descriptor()
.map(|value| value.map(crate::metal4::StaticLinkingDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_static_linking_descriptor(
&self,
value: Option<&crate::metal4::StaticLinkingDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_static_linking_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn tile_function_descriptor(
&self,
) -> Result<Option<crate::metal4::FunctionDescriptor>, crate::Error> {
self.inner
.tile_function_descriptor()
.map(|value| value.map(crate::metal4::FunctionDescriptor::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_tile_function_descriptor(
&self,
value: Option<&crate::metal4::FunctionDescriptor>,
) -> Result<(), crate::Error> {
self.inner
.set_tile_function_descriptor(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_support_binary_linking(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_support_binary_linking(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_threadgroup_size_matches_tile_size(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_threadgroup_size_matches_tile_size(value)
.map_err(crate::Error::from_ffi)
}
}
}
pub(crate) mod metal4_fx {
#[derive(Clone)]
pub struct FrameInterpolator {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4_fx::FrameInterpolator,
}
impl FrameInterpolator {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4_fx::FrameInterpolator,
) -> Self {
Self { inner }
}
pub fn encode_to_command_buffer(
&self,
command_buffer: &mut crate::metal4::RecordingCommandBuffer,
) -> Result<(), crate::Error> {
command_buffer
.as_ffi_mut()
.encode_frame_interpolator(&self.inner)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct SpatialScaler {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4_fx::SpatialScaler,
}
impl SpatialScaler {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4_fx::SpatialScaler,
) -> Self {
Self { inner }
}
pub fn encode_to_command_buffer(
&self,
command_buffer: &mut crate::metal4::RecordingCommandBuffer,
) -> Result<(), crate::Error> {
command_buffer
.as_ffi_mut()
.encode_spatial_scaler(&self.inner)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TemporalDenoisedScaler {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4_fx::TemporalDenoisedScaler,
}
impl TemporalDenoisedScaler {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4_fx::TemporalDenoisedScaler,
) -> Self {
Self { inner }
}
pub fn encode_to_command_buffer(
&self,
command_buffer: &mut crate::metal4::RecordingCommandBuffer,
) -> Result<(), crate::Error> {
command_buffer
.as_ffi_mut()
.encode_temporal_denoised_scaler(&self.inner)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TemporalScaler {
pub(crate) inner: metal_rust_ffi::__private::objects::metal4_fx::TemporalScaler,
}
impl TemporalScaler {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal4_fx::TemporalScaler,
) -> Self {
Self { inner }
}
pub fn encode_to_command_buffer(
&self,
command_buffer: &mut crate::metal4::RecordingCommandBuffer,
) -> Result<(), crate::Error> {
command_buffer
.as_ffi_mut()
.encode_temporal_scaler(&self.inner)
.map_err(crate::Error::from_ffi)
}
}
}
pub(crate) mod metal_fx {
#[derive(Clone)]
pub struct FrameInterpolatableScaler {
pub(crate) inner: metal_rust_ffi::__private::objects::metal_fx::FrameInterpolatableScaler,
}
impl FrameInterpolatableScaler {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal_fx::FrameInterpolatableScaler,
) -> Self {
Self { inner }
}
}
#[derive(Clone)]
pub struct FrameInterpolator {
pub(crate) inner: metal_rust_ffi::__private::objects::metal_fx::FrameInterpolator,
}
impl FrameInterpolator {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal_fx::FrameInterpolator,
) -> Self {
Self { inner }
}
pub fn encode_to_command_buffer(
&self,
command_buffer: &mut crate::metal::CommandBuffer,
) -> Result<(), crate::Error> {
self.inner
.encode_to_command_buffer(&mut command_buffer.inner)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FrameInterpolatorBase {
pub(crate) inner: metal_rust_ffi::__private::objects::metal_fx::FrameInterpolatorBase,
}
impl FrameInterpolatorBase {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal_fx::FrameInterpolatorBase,
) -> Self {
Self { inner }
}
pub fn aspect_ratio(&self) -> Result<f32, crate::Error> {
self.inner.aspect_ratio().map_err(crate::Error::from_ffi)
}
pub fn set_aspect_ratio(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_aspect_ratio(value)
.map_err(crate::Error::from_ffi)
}
pub fn content_height(&self) -> Result<usize, crate::Error> {
self.inner.content_height().map_err(crate::Error::from_ffi)
}
pub fn set_content_height(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_content_height(value)
.map_err(crate::Error::from_ffi)
}
pub fn content_width(&self) -> Result<usize, crate::Error> {
self.inner.content_width().map_err(crate::Error::from_ffi)
}
pub fn set_content_width(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_content_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn delta_time(&self) -> Result<f32, crate::Error> {
self.inner.delta_time().map_err(crate::Error::from_ffi)
}
pub fn set_delta_time(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_delta_time(value)
.map_err(crate::Error::from_ffi)
}
pub fn depth_content_offset_x(&self) -> Result<usize, crate::Error> {
self.inner
.depth_content_offset_x()
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_content_offset_x(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_depth_content_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn depth_content_offset_y(&self) -> Result<usize, crate::Error> {
self.inner
.depth_content_offset_y()
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_content_offset_y(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_depth_content_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn distortion_height(&self) -> Result<usize, crate::Error> {
self.inner
.distortion_height()
.map_err(crate::Error::from_ffi)
}
pub fn set_distortion_height(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_distortion_height(value)
.map_err(crate::Error::from_ffi)
}
pub fn distortion_offset_x(&self) -> Result<usize, crate::Error> {
self.inner
.distortion_offset_x()
.map_err(crate::Error::from_ffi)
}
pub fn set_distortion_offset_x(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_distortion_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn distortion_offset_y(&self) -> Result<usize, crate::Error> {
self.inner
.distortion_offset_y()
.map_err(crate::Error::from_ffi)
}
pub fn set_distortion_offset_y(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_distortion_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn distortion_width(&self) -> Result<usize, crate::Error> {
self.inner
.distortion_width()
.map_err(crate::Error::from_ffi)
}
pub fn set_distortion_width(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_distortion_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn far_plane(&self) -> Result<f32, crate::Error> {
self.inner.far_plane().map_err(crate::Error::from_ffi)
}
pub fn set_far_plane(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_far_plane(value)
.map_err(crate::Error::from_ffi)
}
pub fn field_of_view(&self) -> Result<f32, crate::Error> {
self.inner.field_of_view().map_err(crate::Error::from_ffi)
}
pub fn set_field_of_view(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_field_of_view(value)
.map_err(crate::Error::from_ffi)
}
pub fn input_height(&self) -> Result<usize, crate::Error> {
self.inner.input_height().map_err(crate::Error::from_ffi)
}
pub fn input_width(&self) -> Result<usize, crate::Error> {
self.inner.input_width().map_err(crate::Error::from_ffi)
}
pub fn is_depth_reversed(&self) -> Result<bool, crate::Error> {
self.inner
.is_depth_reversed()
.map_err(crate::Error::from_ffi)
}
pub fn is_ui_texture_composited(&self) -> Result<bool, crate::Error> {
self.inner
.is_ui_texture_composited()
.map_err(crate::Error::from_ffi)
}
pub fn jitter_offset_x(&self) -> Result<f32, crate::Error> {
self.inner.jitter_offset_x().map_err(crate::Error::from_ffi)
}
pub fn set_jitter_offset_x(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_jitter_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn jitter_offset_y(&self) -> Result<f32, crate::Error> {
self.inner.jitter_offset_y().map_err(crate::Error::from_ffi)
}
pub fn set_jitter_offset_y(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_jitter_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_content_offset_x(&self) -> Result<usize, crate::Error> {
self.inner
.motion_content_offset_x()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_content_offset_x(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_content_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_content_offset_y(&self) -> Result<usize, crate::Error> {
self.inner
.motion_content_offset_y()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_content_offset_y(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_content_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_vector_scale_x(&self) -> Result<f32, crate::Error> {
self.inner
.motion_vector_scale_x()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_vector_scale_x(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_motion_vector_scale_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_vector_scale_y(&self) -> Result<f32, crate::Error> {
self.inner
.motion_vector_scale_y()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_vector_scale_y(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_motion_vector_scale_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn near_plane(&self) -> Result<f32, crate::Error> {
self.inner.near_plane().map_err(crate::Error::from_ffi)
}
pub fn set_near_plane(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_near_plane(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_height(&self) -> Result<usize, crate::Error> {
self.inner.output_height().map_err(crate::Error::from_ffi)
}
pub fn output_offset_x(&self) -> Result<usize, crate::Error> {
self.inner.output_offset_x().map_err(crate::Error::from_ffi)
}
pub fn set_output_offset_x(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_output_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_offset_y(&self) -> Result<usize, crate::Error> {
self.inner.output_offset_y().map_err(crate::Error::from_ffi)
}
pub fn set_output_offset_y(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_output_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_width(&self) -> Result<usize, crate::Error> {
self.inner.output_width().map_err(crate::Error::from_ffi)
}
pub fn should_reset_history(&self) -> Result<bool, crate::Error> {
self.inner
.should_reset_history()
.map_err(crate::Error::from_ffi)
}
pub fn color_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.color_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn color_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.color_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn depth_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.depth_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn depth_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.depth_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn motion_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.motion_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn motion_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.motion_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn output_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.output_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn output_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.output_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn ui_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.ui_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn ui_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.ui_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn color_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.color_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_color_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_color_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn depth_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.depth_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_depth_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn distortion_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.distortion_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_distortion_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_distortion_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn fence(&self) -> Result<Option<crate::metal::Fence>, crate::Error> {
self.inner
.fence()
.map(|value| value.map(crate::metal::Fence::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_fence(&self, value: Option<&crate::metal::Fence>) -> Result<(), crate::Error> {
self.inner
.set_fence(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn motion_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.motion_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_motion_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn output_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.output_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_output_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_output_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn prev_color_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.prev_color_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_prev_color_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_prev_color_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn ui_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.ui_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_ui_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_ui_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_reversed(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_depth_reversed(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_is_ui_texture_composited(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_is_ui_texture_composited(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_should_reset_history(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_should_reset_history(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct FrameInterpolatorDescriptor {
pub(crate) inner: metal_rust_ffi::__private::objects::metal_fx::FrameInterpolatorDescriptor,
}
impl FrameInterpolatorDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal_fx::FrameInterpolatorDescriptor,
) -> Self {
Self { inner }
}
pub fn new() -> Result<Self, crate::Error> {
metal_rust_ffi::__private::objects::metal_fx::FrameInterpolatorDescriptor::new()
.map(Self::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn input_height(&self) -> Result<usize, crate::Error> {
self.inner.input_height().map_err(crate::Error::from_ffi)
}
pub fn set_input_height(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_input_height(value)
.map_err(crate::Error::from_ffi)
}
pub fn input_width(&self) -> Result<usize, crate::Error> {
self.inner.input_width().map_err(crate::Error::from_ffi)
}
pub fn set_input_width(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_input_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn is_distortion_texture_enabled(&self) -> Result<usize, crate::Error> {
self.inner
.is_distortion_texture_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn output_height(&self) -> Result<usize, crate::Error> {
self.inner.output_height().map_err(crate::Error::from_ffi)
}
pub fn set_output_height(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_output_height(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_width(&self) -> Result<usize, crate::Error> {
self.inner.output_width().map_err(crate::Error::from_ffi)
}
pub fn set_output_width(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_output_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn color_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.color_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_color_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_color_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn depth_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.depth_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_depth_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.motion_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_motion_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.output_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_output_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_output_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn ui_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.ui_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_ui_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_ui_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn scaler(
&self,
) -> Result<Option<crate::metal_fx::FrameInterpolatableScaler>, crate::Error> {
self.inner
.scaler()
.map(|value| value.map(crate::metal_fx::FrameInterpolatableScaler::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_scaler(
&self,
value: Option<&crate::metal_fx::FrameInterpolatableScaler>,
) -> Result<(), crate::Error> {
self.inner
.set_scaler(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_distortion_texture_enabled(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_distortion_texture_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn new_frame_interpolator(
&self,
device: &crate::metal::Device,
compiler: &crate::metal4::Compiler,
) -> Result<crate::metal4_fx::FrameInterpolator, crate::Error> {
self.inner
.new_frame_interpolator(&device.inner, &compiler.inner)
.map(crate::metal4_fx::FrameInterpolator::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn supports_device(device: &crate::metal::Device) -> Result<bool, crate::Error> {
metal_rust_ffi::__private::objects::metal_fx::FrameInterpolatorDescriptor::supports_device(&device.inner).map_err(crate::Error::from_ffi)
}
pub fn supports_metal4_fx(device: &crate::metal::Device) -> Result<bool, crate::Error> {
metal_rust_ffi::__private::objects::metal_fx::FrameInterpolatorDescriptor::supports_metal4_fx(&device.inner).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct SpatialScalerBase {
pub(crate) inner: metal_rust_ffi::__private::objects::metal_fx::SpatialScalerBase,
}
impl SpatialScalerBase {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal_fx::SpatialScalerBase,
) -> Self {
Self { inner }
}
pub fn input_content_height(&self) -> Result<usize, crate::Error> {
self.inner
.input_content_height()
.map_err(crate::Error::from_ffi)
}
pub fn set_input_content_height(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_input_content_height(value)
.map_err(crate::Error::from_ffi)
}
pub fn input_content_width(&self) -> Result<usize, crate::Error> {
self.inner
.input_content_width()
.map_err(crate::Error::from_ffi)
}
pub fn set_input_content_width(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_input_content_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn input_height(&self) -> Result<usize, crate::Error> {
self.inner.input_height().map_err(crate::Error::from_ffi)
}
pub fn input_width(&self) -> Result<usize, crate::Error> {
self.inner.input_width().map_err(crate::Error::from_ffi)
}
pub fn output_height(&self) -> Result<usize, crate::Error> {
self.inner.output_height().map_err(crate::Error::from_ffi)
}
pub fn output_width(&self) -> Result<usize, crate::Error> {
self.inner.output_width().map_err(crate::Error::from_ffi)
}
pub fn color_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.color_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn color_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.color_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn output_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.output_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn output_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.output_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn color_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.color_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_color_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_color_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn fence(&self) -> Result<Option<crate::metal::Fence>, crate::Error> {
self.inner
.fence()
.map(|value| value.map(crate::metal::Fence::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_fence(&self, value: Option<&crate::metal::Fence>) -> Result<(), crate::Error> {
self.inner
.set_fence(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn output_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.output_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_output_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_output_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TemporalDenoisedScaler {
pub(crate) inner: metal_rust_ffi::__private::objects::metal_fx::TemporalDenoisedScaler,
}
impl TemporalDenoisedScaler {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal_fx::TemporalDenoisedScaler,
) -> Self {
Self { inner }
}
pub fn encode_to_command_buffer(
&self,
command_buffer: &mut crate::metal::CommandBuffer,
) -> Result<(), crate::Error> {
self.inner
.encode_to_command_buffer(&mut command_buffer.inner)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TemporalDenoisedScalerBase {
pub(crate) inner: metal_rust_ffi::__private::objects::metal_fx::TemporalDenoisedScalerBase,
}
impl TemporalDenoisedScalerBase {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal_fx::TemporalDenoisedScalerBase,
) -> Self {
Self { inner }
}
pub fn input_content_max_scale(&self) -> Result<f32, crate::Error> {
self.inner
.input_content_max_scale()
.map_err(crate::Error::from_ffi)
}
pub fn input_content_min_scale(&self) -> Result<f32, crate::Error> {
self.inner
.input_content_min_scale()
.map_err(crate::Error::from_ffi)
}
pub fn input_height(&self) -> Result<usize, crate::Error> {
self.inner.input_height().map_err(crate::Error::from_ffi)
}
pub fn input_width(&self) -> Result<usize, crate::Error> {
self.inner.input_width().map_err(crate::Error::from_ffi)
}
pub fn is_depth_reversed(&self) -> Result<bool, crate::Error> {
self.inner
.is_depth_reversed()
.map_err(crate::Error::from_ffi)
}
pub fn jitter_offset_x(&self) -> Result<f32, crate::Error> {
self.inner.jitter_offset_x().map_err(crate::Error::from_ffi)
}
pub fn set_jitter_offset_x(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_jitter_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn jitter_offset_y(&self) -> Result<f32, crate::Error> {
self.inner.jitter_offset_y().map_err(crate::Error::from_ffi)
}
pub fn set_jitter_offset_y(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_jitter_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_vector_scale_x(&self) -> Result<f32, crate::Error> {
self.inner
.motion_vector_scale_x()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_vector_scale_x(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_motion_vector_scale_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_vector_scale_y(&self) -> Result<f32, crate::Error> {
self.inner
.motion_vector_scale_y()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_vector_scale_y(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_motion_vector_scale_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_height(&self) -> Result<usize, crate::Error> {
self.inner.output_height().map_err(crate::Error::from_ffi)
}
pub fn output_width(&self) -> Result<usize, crate::Error> {
self.inner.output_width().map_err(crate::Error::from_ffi)
}
pub fn pre_exposure(&self) -> Result<f32, crate::Error> {
self.inner.pre_exposure().map_err(crate::Error::from_ffi)
}
pub fn set_pre_exposure(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_pre_exposure(value)
.map_err(crate::Error::from_ffi)
}
pub fn should_reset_history(&self) -> Result<bool, crate::Error> {
self.inner
.should_reset_history()
.map_err(crate::Error::from_ffi)
}
pub fn color_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.color_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn color_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.color_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn denoise_strength_mask_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.denoise_strength_mask_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn denoise_strength_mask_texture_usage(
&self,
) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.denoise_strength_mask_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn depth_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.depth_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn depth_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.depth_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn diffuse_albedo_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.diffuse_albedo_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn diffuse_albedo_texture_usage(
&self,
) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.diffuse_albedo_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn motion_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.motion_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn motion_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.motion_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn normal_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.normal_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn normal_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.normal_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn output_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.output_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn output_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.output_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn reactive_mask_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.reactive_mask_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn reactive_mask_texture_usage(
&self,
) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.reactive_mask_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn roughness_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.roughness_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn roughness_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.roughness_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn specular_albedo_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.specular_albedo_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn specular_albedo_texture_usage(
&self,
) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.specular_albedo_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn specular_hit_distance_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.specular_hit_distance_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn specular_hit_distance_texture_usage(
&self,
) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.specular_hit_distance_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn transparency_overlay_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.transparency_overlay_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn transparency_overlay_texture_usage(
&self,
) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.transparency_overlay_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn color_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.color_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_color_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_color_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn denoise_strength_mask_texture(
&self,
) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.denoise_strength_mask_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_denoise_strength_mask_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_denoise_strength_mask_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn depth_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.depth_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_depth_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn diffuse_albedo_texture(
&self,
) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.diffuse_albedo_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_diffuse_albedo_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_diffuse_albedo_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn exposure_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.exposure_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_exposure_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_exposure_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn fence(&self) -> Result<Option<crate::metal::Fence>, crate::Error> {
self.inner
.fence()
.map(|value| value.map(crate::metal::Fence::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_fence(&self, value: Option<&crate::metal::Fence>) -> Result<(), crate::Error> {
self.inner
.set_fence(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn motion_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.motion_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_motion_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn normal_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.normal_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_normal_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_normal_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn output_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.output_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_output_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_output_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn reactive_mask_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.reactive_mask_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_reactive_mask_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_reactive_mask_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn roughness_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.roughness_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_roughness_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_roughness_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn specular_albedo_texture(
&self,
) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.specular_albedo_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_specular_albedo_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_specular_albedo_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn specular_hit_distance_texture(
&self,
) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.specular_hit_distance_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_specular_hit_distance_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_specular_hit_distance_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn transparency_overlay_texture(
&self,
) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.transparency_overlay_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_transparency_overlay_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_transparency_overlay_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_reversed(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_depth_reversed(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_should_reset_history(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_should_reset_history(value)
.map_err(crate::Error::from_ffi)
}
pub fn world_to_view_matrix(&self) -> Result<crate::metal_fx::Matrix4x4, crate::Error> {
self.inner
.world_to_view_matrix()
.map_err(crate::Error::from_ffi)
}
pub fn set_world_to_view_matrix(
&self,
value: crate::metal_fx::Matrix4x4,
) -> Result<(), crate::Error> {
self.inner
.set_world_to_view_matrix(value)
.map_err(crate::Error::from_ffi)
}
pub fn view_to_clip_matrix(&self) -> Result<crate::metal_fx::Matrix4x4, crate::Error> {
self.inner
.view_to_clip_matrix()
.map_err(crate::Error::from_ffi)
}
pub fn set_view_to_clip_matrix(
&self,
value: crate::metal_fx::Matrix4x4,
) -> Result<(), crate::Error> {
self.inner
.set_view_to_clip_matrix(value)
.map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TemporalDenoisedScalerDescriptor {
pub(crate) inner:
metal_rust_ffi::__private::objects::metal_fx::TemporalDenoisedScalerDescriptor,
}
impl TemporalDenoisedScalerDescriptor {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal_fx::TemporalDenoisedScalerDescriptor,
) -> Self {
Self { inner }
}
pub fn input_content_max_scale(&self) -> Result<f32, crate::Error> {
self.inner
.input_content_max_scale()
.map_err(crate::Error::from_ffi)
}
pub fn set_input_content_max_scale(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_input_content_max_scale(value)
.map_err(crate::Error::from_ffi)
}
pub fn input_content_min_scale(&self) -> Result<f32, crate::Error> {
self.inner
.input_content_min_scale()
.map_err(crate::Error::from_ffi)
}
pub fn set_input_content_min_scale(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_input_content_min_scale(value)
.map_err(crate::Error::from_ffi)
}
pub fn input_height(&self) -> Result<usize, crate::Error> {
self.inner.input_height().map_err(crate::Error::from_ffi)
}
pub fn set_input_height(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_input_height(value)
.map_err(crate::Error::from_ffi)
}
pub fn input_width(&self) -> Result<usize, crate::Error> {
self.inner.input_width().map_err(crate::Error::from_ffi)
}
pub fn set_input_width(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_input_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn is_auto_exposure_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_auto_exposure_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn is_denoise_strength_mask_texture_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_denoise_strength_mask_texture_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn is_input_content_properties_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_input_content_properties_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn is_reactive_mask_texture_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_reactive_mask_texture_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn is_specular_hit_distance_texture_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_specular_hit_distance_texture_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn is_transparency_overlay_texture_enabled(&self) -> Result<bool, crate::Error> {
self.inner
.is_transparency_overlay_texture_enabled()
.map_err(crate::Error::from_ffi)
}
pub fn output_height(&self) -> Result<usize, crate::Error> {
self.inner.output_height().map_err(crate::Error::from_ffi)
}
pub fn set_output_height(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_output_height(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_width(&self) -> Result<usize, crate::Error> {
self.inner.output_width().map_err(crate::Error::from_ffi)
}
pub fn set_output_width(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_output_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn requires_synchronous_initialization(&self) -> Result<bool, crate::Error> {
self.inner
.requires_synchronous_initialization()
.map_err(crate::Error::from_ffi)
}
pub fn color_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.color_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_color_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_color_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn denoise_strength_mask_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.denoise_strength_mask_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_denoise_strength_mask_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_denoise_strength_mask_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn depth_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.depth_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_depth_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn diffuse_albedo_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.diffuse_albedo_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_diffuse_albedo_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_diffuse_albedo_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.motion_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_motion_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn normal_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.normal_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_normal_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_normal_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.output_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_output_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_output_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn reactive_mask_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.reactive_mask_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_reactive_mask_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_reactive_mask_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn roughness_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.roughness_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_roughness_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_roughness_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn specular_albedo_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.specular_albedo_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_specular_albedo_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_specular_albedo_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn specular_hit_distance_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.specular_hit_distance_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_specular_hit_distance_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_specular_hit_distance_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn transparency_overlay_texture_format(
&self,
) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.transparency_overlay_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn set_transparency_overlay_texture_format(
&self,
value: crate::metal::PixelFormat,
) -> Result<(), crate::Error> {
self.inner
.set_transparency_overlay_texture_format(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_auto_exposure_enabled(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_auto_exposure_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_denoise_strength_mask_texture_enabled(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_denoise_strength_mask_texture_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_input_content_properties_enabled(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_input_content_properties_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_reactive_mask_texture_enabled(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_reactive_mask_texture_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_requires_synchronous_initialization(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_requires_synchronous_initialization(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_specular_hit_distance_texture_enabled(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_specular_hit_distance_texture_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_transparency_overlay_texture_enabled(
&self,
value: bool,
) -> Result<(), crate::Error> {
self.inner
.set_transparency_overlay_texture_enabled(value)
.map_err(crate::Error::from_ffi)
}
pub fn new_temporal_denoised_scaler(
&self,
device: &crate::metal::Device,
compiler: &crate::metal4::Compiler,
) -> Result<crate::metal4_fx::TemporalDenoisedScaler, crate::Error> {
self.inner
.new_temporal_denoised_scaler(&device.inner, &compiler.inner)
.map(crate::metal4_fx::TemporalDenoisedScaler::from_ffi)
.map_err(crate::Error::from_ffi)
}
pub fn supported_input_content_max_scale(
device: &crate::metal::Device,
) -> Result<f32, crate::Error> {
metal_rust_ffi::__private::objects::metal_fx::TemporalDenoisedScalerDescriptor::supported_input_content_max_scale(&device.inner).map_err(crate::Error::from_ffi)
}
pub fn supported_input_content_min_scale(
device: &crate::metal::Device,
) -> Result<f32, crate::Error> {
metal_rust_ffi::__private::objects::metal_fx::TemporalDenoisedScalerDescriptor::supported_input_content_min_scale(&device.inner).map_err(crate::Error::from_ffi)
}
pub fn supports_device(device: &crate::metal::Device) -> Result<bool, crate::Error> {
metal_rust_ffi::__private::objects::metal_fx::TemporalDenoisedScalerDescriptor::supports_device(&device.inner).map_err(crate::Error::from_ffi)
}
pub fn supports_metal4_fx(device: &crate::metal::Device) -> Result<bool, crate::Error> {
metal_rust_ffi::__private::objects::metal_fx::TemporalDenoisedScalerDescriptor::supports_metal4_fx(&device.inner).map_err(crate::Error::from_ffi)
}
}
#[derive(Clone)]
pub struct TemporalScalerBase {
pub(crate) inner: metal_rust_ffi::__private::objects::metal_fx::TemporalScalerBase,
}
impl TemporalScalerBase {
pub(crate) const fn from_ffi(
inner: metal_rust_ffi::__private::objects::metal_fx::TemporalScalerBase,
) -> Self {
Self { inner }
}
pub fn color_content_offset_x(&self) -> Result<usize, crate::Error> {
self.inner
.color_content_offset_x()
.map_err(crate::Error::from_ffi)
}
pub fn set_color_content_offset_x(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_color_content_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn color_content_offset_y(&self) -> Result<usize, crate::Error> {
self.inner
.color_content_offset_y()
.map_err(crate::Error::from_ffi)
}
pub fn set_color_content_offset_y(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_color_content_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn depth_content_offset_x(&self) -> Result<usize, crate::Error> {
self.inner
.depth_content_offset_x()
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_content_offset_x(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_depth_content_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn depth_content_offset_y(&self) -> Result<usize, crate::Error> {
self.inner
.depth_content_offset_y()
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_content_offset_y(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_depth_content_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn input_content_height(&self) -> Result<usize, crate::Error> {
self.inner
.input_content_height()
.map_err(crate::Error::from_ffi)
}
pub fn set_input_content_height(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_input_content_height(value)
.map_err(crate::Error::from_ffi)
}
pub fn input_content_max_scale(&self) -> Result<f32, crate::Error> {
self.inner
.input_content_max_scale()
.map_err(crate::Error::from_ffi)
}
pub fn input_content_min_scale(&self) -> Result<f32, crate::Error> {
self.inner
.input_content_min_scale()
.map_err(crate::Error::from_ffi)
}
pub fn input_content_width(&self) -> Result<usize, crate::Error> {
self.inner
.input_content_width()
.map_err(crate::Error::from_ffi)
}
pub fn set_input_content_width(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_input_content_width(value)
.map_err(crate::Error::from_ffi)
}
pub fn input_height(&self) -> Result<usize, crate::Error> {
self.inner.input_height().map_err(crate::Error::from_ffi)
}
pub fn input_width(&self) -> Result<usize, crate::Error> {
self.inner.input_width().map_err(crate::Error::from_ffi)
}
pub fn is_depth_reversed(&self) -> Result<bool, crate::Error> {
self.inner
.is_depth_reversed()
.map_err(crate::Error::from_ffi)
}
pub fn jitter_offset_x(&self) -> Result<f32, crate::Error> {
self.inner.jitter_offset_x().map_err(crate::Error::from_ffi)
}
pub fn set_jitter_offset_x(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_jitter_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn jitter_offset_y(&self) -> Result<f32, crate::Error> {
self.inner.jitter_offset_y().map_err(crate::Error::from_ffi)
}
pub fn set_jitter_offset_y(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_jitter_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_content_offset_x(&self) -> Result<usize, crate::Error> {
self.inner
.motion_content_offset_x()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_content_offset_x(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_content_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_content_offset_y(&self) -> Result<usize, crate::Error> {
self.inner
.motion_content_offset_y()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_content_offset_y(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_motion_content_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_vector_scale_x(&self) -> Result<f32, crate::Error> {
self.inner
.motion_vector_scale_x()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_vector_scale_x(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_motion_vector_scale_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn motion_vector_scale_y(&self) -> Result<f32, crate::Error> {
self.inner
.motion_vector_scale_y()
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_vector_scale_y(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_motion_vector_scale_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_height(&self) -> Result<usize, crate::Error> {
self.inner.output_height().map_err(crate::Error::from_ffi)
}
pub fn output_offset_x(&self) -> Result<usize, crate::Error> {
self.inner.output_offset_x().map_err(crate::Error::from_ffi)
}
pub fn set_output_offset_x(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_output_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_offset_y(&self) -> Result<usize, crate::Error> {
self.inner.output_offset_y().map_err(crate::Error::from_ffi)
}
pub fn set_output_offset_y(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_output_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn output_width(&self) -> Result<usize, crate::Error> {
self.inner.output_width().map_err(crate::Error::from_ffi)
}
pub fn pre_exposure(&self) -> Result<f32, crate::Error> {
self.inner.pre_exposure().map_err(crate::Error::from_ffi)
}
pub fn set_pre_exposure(&self, value: f32) -> Result<(), crate::Error> {
self.inner
.set_pre_exposure(value)
.map_err(crate::Error::from_ffi)
}
pub fn reactive_mask_content_offset_x(&self) -> Result<usize, crate::Error> {
self.inner
.reactive_mask_content_offset_x()
.map_err(crate::Error::from_ffi)
}
pub fn set_reactive_mask_content_offset_x(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_reactive_mask_content_offset_x(value)
.map_err(crate::Error::from_ffi)
}
pub fn reactive_mask_content_offset_y(&self) -> Result<usize, crate::Error> {
self.inner
.reactive_mask_content_offset_y()
.map_err(crate::Error::from_ffi)
}
pub fn set_reactive_mask_content_offset_y(&self, value: usize) -> Result<(), crate::Error> {
self.inner
.set_reactive_mask_content_offset_y(value)
.map_err(crate::Error::from_ffi)
}
pub fn reset(&self) -> Result<bool, crate::Error> {
self.inner.reset().map_err(crate::Error::from_ffi)
}
pub fn color_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.color_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn color_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.color_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn depth_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.depth_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn depth_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.depth_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn motion_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.motion_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn motion_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.motion_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn output_texture_format(&self) -> Result<crate::metal::PixelFormat, crate::Error> {
self.inner
.output_texture_format()
.map_err(crate::Error::from_ffi)
}
pub fn output_texture_usage(&self) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.output_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn reactive_mask_texture_usage(
&self,
) -> Result<crate::metal::TextureUsage, crate::Error> {
self.inner
.reactive_mask_texture_usage()
.map_err(crate::Error::from_ffi)
}
pub fn color_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.color_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_color_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_color_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn depth_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.depth_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_depth_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn exposure_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.exposure_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_exposure_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_exposure_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn fence(&self) -> Result<Option<crate::metal::Fence>, crate::Error> {
self.inner
.fence()
.map(|value| value.map(crate::metal::Fence::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_fence(&self, value: Option<&crate::metal::Fence>) -> Result<(), crate::Error> {
self.inner
.set_fence(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn motion_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.motion_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_motion_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_motion_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn output_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.output_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_output_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_output_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn reactive_mask_texture(&self) -> Result<Option<crate::metal::Texture>, crate::Error> {
self.inner
.reactive_mask_texture()
.map(|value| value.map(crate::metal::Texture::from_ffi))
.map_err(crate::Error::from_ffi)
}
pub fn set_reactive_mask_texture(
&self,
value: Option<&crate::metal::Texture>,
) -> Result<(), crate::Error> {
self.inner
.set_reactive_mask_texture(value.map(|value| &value.inner))
.map_err(crate::Error::from_ffi)
}
pub fn set_depth_reversed(&self, value: bool) -> Result<(), crate::Error> {
self.inner
.set_depth_reversed(value)
.map_err(crate::Error::from_ffi)
}
pub fn set_reset(&self, value: bool) -> Result<(), crate::Error> {
self.inner.set_reset(value).map_err(crate::Error::from_ffi)
}
}
}