iron-oxide 0.1.1

Unsafe Rusty Metal.
Documentation 
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

use crate::import_objc_macros::*;
use crate::{
    handle, DeviceCreated, MTLComputeCommandEncoder, MTLDrawable, MTLParallelRenderCommandEncoder,
    MTLRenderCommandEncoder, MTLRenderPassDescriptor, NSError, Object, ObjectPointer,
};

#[repr(u64)]
pub enum MTLCommandBufferStatus {
    NotEnqueued = 0,
    Enqueued = 1,
    Committed = 2,
    Scheduled = 3,
    Completed = 4,
    Error = 5,
}

pub struct MTLCommandBuffer(ObjectPointer);
handle!(MTLCommandBuffer);

impl MTLCommandBuffer {
    pub unsafe fn enqueue(&self) {
        msg_send![self.get_ptr(), enqueue]
    }
    pub unsafe fn commit(&self) {
        msg_send![self.get_ptr(), commit]
    }
    pub unsafe fn wait_until_scheduled(&self) {
        msg_send![self.get_ptr(), waitUntilScheduled]
    }
    pub unsafe fn wait_until_completed(&self) {
        msg_send![self.get_ptr(), waitUntilCompleted]
    }
    pub unsafe fn present_drawable<T: MTLDrawable>(&self, drawable: &T) {
        msg_send![self.get_ptr(), presentDrawable:drawable.get_ptr()]
    }
    pub unsafe fn present_drawable_after_min_duration<T: MTLDrawable>(
        &self,
        drawable: T,
        duration: f64,
    ) {
        msg_send![self.get_ptr(), presentDrawable:drawable.get_ptr() afterMinimumDuration:duration]
    }
    pub unsafe fn present_drawable_at_time<T: MTLDrawable>(&self, drawable: T, time: f64) {
        msg_send![self.get_ptr(), presentDrawable:drawable.get_ptr() atTime:time]
    }
    pub unsafe fn get_status(&self) -> MTLCommandBufferStatus {
        msg_send![self.get_ptr(), status]
    }
    pub unsafe fn get_error(&self) -> Option<NSError> {
        let err = ObjectPointer(msg_send![self.get_ptr(), error]);
        if err.0.is_null() {
            None
        } else {
            Some(NSError::from_ptr(err))
        }
    }
    pub unsafe fn get_kernel_start_time(&self) -> f64 {
        msg_send![self.get_ptr(), kernelStartTime]
    }
    pub unsafe fn get_kernel_end_time(&self) -> f64 {
        msg_send![self.get_ptr(), kernelEndTime]
    }
    pub unsafe fn new_render_command_encoder_with_descriptor(
        &self,
        desc: &MTLRenderPassDescriptor,
    ) -> MTLRenderCommandEncoder {
        MTLRenderCommandEncoder::from_ptr({
            let k = ObjectPointer(msg_send![
                self.get_ptr(),
                renderCommandEncoderWithDescriptor: desc.get_ptr()
            ]);
            msg_send![k, retain]
        })
    }
    pub unsafe fn new_parallel_render_command_encoder_with_descriptor(
        &self,
        desc: &MTLRenderPassDescriptor,
    ) -> MTLParallelRenderCommandEncoder {
        MTLParallelRenderCommandEncoder::from_ptr({
            let k = ObjectPointer(msg_send![
                self.get_ptr(),
                parallelRenderCommandEncoderWithDescriptor: desc.get_ptr()
            ]);
            msg_send![k, retain]
        })
    }
    pub unsafe fn new_compute_encoder(&self) -> MTLComputeCommandEncoder {
        MTLComputeCommandEncoder::from_ptr({
            let k = ObjectPointer(msg_send![self.get_ptr(), computeCommandEncoder]);
            msg_send![k, retain]
        })
    }
}

impl Object for MTLCommandBuffer {
    unsafe fn from_ptr(ptr: ObjectPointer) -> Self
    where
        Self: Sized,
    {
        MTLCommandBuffer(ptr)
    }

    fn get_ptr(&self) -> ObjectPointer {
        self.0
    }
}

impl DeviceCreated for MTLCommandBuffer {}