mtl-rs 0.1.8

Rust bindings for Apple's Metal API
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use core::ffi::c_float;

use objc2::{
    extern_class, extern_conformance, extern_methods, msg_send,
    rc::{Allocated, Retained},
};
use objc2_foundation::{CopyingHelper, NSArray, NSCopying, NSObject, NSObjectProtocol, NSUInteger};

use crate::*;

extern_class!(
    /// Descriptor for a primitive acceleration structure that directly references geometric shapes, such as triangles and
    /// bounding boxes.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metal/mtl4primitiveaccelerationstructuredescriptor?language=objc)
    #[unsafe(super(MTL4AccelerationStructureDescriptor, MTLAccelerationStructureDescriptor, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MTL4PrimitiveAccelerationStructureDescriptor;
);

extern_conformance!(
    unsafe impl NSCopying for MTL4PrimitiveAccelerationStructureDescriptor {}
);

unsafe impl CopyingHelper for MTL4PrimitiveAccelerationStructureDescriptor {
    type Result = Self;
}

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

impl MTL4PrimitiveAccelerationStructureDescriptor {
    extern_methods!(
        /// Configures the behavior when the ray-tracing system samples the acceleration structure before the motion start time.
        ///
        /// Use this property to control the behavior when the ray-tracing system samples the acceleration structure
        /// at a time prior to the one you set for ``motionStartTime``.
        ///
        /// The default value of this property is `MTLMotionBorderModeClamp`.
        #[unsafe(method(motionStartBorderMode))]
        #[unsafe(method_family = none)]
        pub fn motion_start_border_mode(&self) -> MTLMotionBorderMode;

        /// Setter for [`motionStartBorderMode`][Self::motionStartBorderMode].
        #[unsafe(method(setMotionStartBorderMode:))]
        #[unsafe(method_family = none)]
        pub fn set_motion_start_border_mode(
            &self,
            motion_start_border_mode: MTLMotionBorderMode,
        );

        /// Configures the motion border mode.
        ///
        /// This property controls what happens if Metal samples the acceleration structure after ``motionEndTime``.
        ///
        /// Its default value is `MTLMotionBorderModeClamp`.
        #[unsafe(method(motionEndBorderMode))]
        #[unsafe(method_family = none)]
        pub fn motion_end_border_mode(&self) -> MTLMotionBorderMode;

        /// Setter for [`motionEndBorderMode`][Self::motionEndBorderMode].
        #[unsafe(method(setMotionEndBorderMode:))]
        #[unsafe(method_family = none)]
        pub fn set_motion_end_border_mode(
            &self,
            motion_end_border_mode: MTLMotionBorderMode,
        );

        /// Configures the motion start time for this geometry.
        ///
        /// The default value of this property is `0.0f`.
        #[unsafe(method(motionStartTime))]
        #[unsafe(method_family = none)]
        pub fn motion_start_time(&self) -> c_float;

        /// Setter for [`motionStartTime`][Self::motionStartTime].
        #[unsafe(method(setMotionStartTime:))]
        #[unsafe(method_family = none)]
        pub fn set_motion_start_time(
            &self,
            motion_start_time: c_float,
        );

        /// Configures the motion end time for this geometry.
        ///
        /// The default value of this property is `1.0f`.
        #[unsafe(method(motionEndTime))]
        #[unsafe(method_family = none)]
        pub fn motion_end_time(&self) -> c_float;

        /// Setter for [`motionEndTime`][Self::motionEndTime].
        #[unsafe(method(setMotionEndTime:))]
        #[unsafe(method_family = none)]
        pub fn set_motion_end_time(
            &self,
            motion_end_time: c_float,
        );

        /// Sets the motion keyframe count.
        ///
        /// This property's default is `1`, indicating no motion.
        #[unsafe(method(motionKeyframeCount))]
        #[unsafe(method_family = none)]
        pub fn motion_keyframe_count(&self) -> NSUInteger;

        /// Setter for [`motionKeyframeCount`][Self::motionKeyframeCount].
        #[unsafe(method(setMotionKeyframeCount:))]
        #[unsafe(method_family = none)]
        pub fn set_motion_keyframe_count(
            &self,
            motion_keyframe_count: NSUInteger,
        );
    );
}

/// Methods declared on superclass `NSObject`.
impl MTL4PrimitiveAccelerationStructureDescriptor {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub fn init(this: Allocated<Self>) -> Retained<Self>;

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

impl MTL4PrimitiveAccelerationStructureDescriptor {
    /// Associates the array of geometry descriptors that comprise this primitive acceleration structure.
    pub fn geometry_descriptors(&self) -> Option<Box<[Retained<MTL4AccelerationStructureGeometryDescriptor>]>> {
        let arr: Option<Retained<NSArray<MTL4AccelerationStructureGeometryDescriptor>>> =
            unsafe { msg_send![self, geometryDescriptors] };
        arr.map(|a| a.to_vec().into_boxed_slice())
    }

    /// Setter for geometry_descriptors.
    pub fn set_geometry_descriptors(
        &self,
        geometry_descriptors: Option<&[&MTL4AccelerationStructureGeometryDescriptor]>,
    ) {
        let ns_array = geometry_descriptors.map(NSArray::from_slice);
        unsafe {
            let _: () = msg_send![self, setGeometryDescriptors: ns_array.as_deref()];
        }
    }
}