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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::import_objc_macros::*;
use crate::{
    handle, MTLBuffer, MTLCommandEncoder, MTLComputePipelineState, MTLSamplerState, MTLSize,
    MTLTexture, NSRange, NSUInteger, NSUIntegerRange, Object, ObjectPointer,
};
use std::os::raw::c_void;

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

impl MTLComputeCommandEncoder {
    pub unsafe fn set_compute_pipeline_state(&self, state: &MTLComputePipelineState) {
        msg_send![self.get_ptr(), setComputePipelineState:state.get_ptr()]
    }
    pub unsafe fn set_buffer(&self, buffer: &MTLBuffer, offset: NSUInteger, index: NSUInteger) {
        msg_send![self.get_ptr(), setBuffer:buffer.get_ptr() offset:offset atIndex:index]
    }
    pub unsafe fn set_buffers(
        &self,
        buffers: &[&MTLBuffer],
        offsets: &[NSUInteger],
        range: NSUIntegerRange,
    ) {
        let range = NSRange {
            location: range.start,
            length: range.end - range.start,
        };
        let pointers = buffers
            .iter()
            .map(|buffer| buffer.get_ptr())
            .collect::<Vec<ObjectPointer>>();
        let pointers = pointers.as_slice().as_ptr();

        msg_send![self.get_ptr(), setBuffers:pointers offsets:offsets.as_ptr() withRange:range]
    }
    pub unsafe fn set_buffer_offset(&self, offset: NSUInteger, index: NSUInteger) {
        msg_send![self.get_ptr(), setBufferOffset:offset atIndex:index]
    }
    pub unsafe fn set_bytes(&self, bytes: *const c_void, length: NSUInteger, index: NSUInteger) {
        msg_send![self.get_ptr(), setBytes:bytes length:length atIndex:index]
    }
    pub unsafe fn set_sampler_state(&self, sampler: &MTLSamplerState, index: NSUInteger) {
        msg_send![self.get_ptr(), setSamplerState:sampler.get_ptr() atIndex:index]
    }
    pub unsafe fn set_sampler_state_clamp(
        &self,
        sampler: &MTLSamplerState,
        lod_min_clamp: f32,
        lod_max_clamp: f32,
        index: NSUInteger,
    ) {
        msg_send![
            self.get_ptr(),
            setVertexSamplerState:sampler.get_ptr()
            lodMinClamp:lod_min_clamp
            lodMaxClamp:lod_max_clamp
            atIndex:index
        ]
    }
    pub unsafe fn set_sampler_states(&self, samplers: &[MTLSamplerState], range: NSUIntegerRange) {
        let pointers = samplers
            .iter()
            .map(|sampler| sampler.get_ptr())
            .collect::<Vec<_>>();
        let pointers = pointers.as_slice().as_ptr();
        let range = NSRange {
            location: range.start,
            length: range.end - range.start,
        };
        msg_send![self.get_ptr(), setSamplerStates:pointers withRange:range]
    }
    pub unsafe fn set_texture(&self, texture: &MTLTexture, index: NSUInteger) {
        msg_send![self.get_ptr(), setTexture:texture.get_ptr() atIndex:index]
    }
    pub unsafe fn set_textures(&self, textures: &[&MTLTexture], range: NSUIntegerRange) {
        let pointers = textures
            .iter()
            .map(|texture| texture.get_ptr())
            .collect::<Vec<_>>();
        let pointers = pointers.as_slice().as_ptr();
        let range = NSRange {
            location: range.start,
            length: range.end - range.start,
        };
        msg_send![self.get_ptr(), setTextures:pointers withRange:range]
    }
    pub unsafe fn set_threadgroup_memory_length(&self, length: NSUInteger, index: NSUInteger) {
        msg_send![self.get_ptr(), setThreadgroupMemoryLength:length atIndex:index]
    }
    pub unsafe fn dispatch_threadgroups(
        &self,
        threadgroups_per_grid: MTLSize,
        threads_per_threadgroup: MTLSize,
    ) {
        msg_send![
            self.get_ptr(),
            dispatchThreadgroups:threadgroups_per_grid
            threadsPerThreadgroup:threads_per_threadgroup
        ]
    }
    pub unsafe fn dispatch_threads(
        &self,
        threads_per_grid: MTLSize,
        threads_per_threadgroup: MTLSize,
    ) {
        msg_send![
            self.get_ptr(),
            dispatchThreads:threads_per_grid
            threadsPerThreadgroup:threads_per_threadgroup
        ]
    }
}

impl MTLCommandEncoder for MTLComputeCommandEncoder {}

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

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