modelio-rs 0.3.1

Safe Rust bindings for Apple's ModelIO framework — assets, meshes, materials, lights, cameras, voxels, textures, and animation on macOS
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

import Foundation
import ModelIO
import simd

private func mdl_double_matrix_to_float_array(_ matrix: matrix_double4x4) -> [Float] {
    [
        Float(matrix.columns.0.x), Float(matrix.columns.0.y), Float(matrix.columns.0.z), Float(matrix.columns.0.w),
        Float(matrix.columns.1.x), Float(matrix.columns.1.y), Float(matrix.columns.1.z), Float(matrix.columns.1.w),
        Float(matrix.columns.2.x), Float(matrix.columns.2.y), Float(matrix.columns.2.z), Float(matrix.columns.2.w),
        Float(matrix.columns.3.x), Float(matrix.columns.3.y), Float(matrix.columns.3.z), Float(matrix.columns.3.w),
    ]
}

private func mdl_float_array_to_double_matrix(_ values: UnsafePointer<Float>?) -> matrix_double4x4 {
    let matrix = mdl_matrix_from_array(values)
    return matrix_double4x4(columns: (
        SIMD4<Double>(Double(matrix.columns.0.x), Double(matrix.columns.0.y), Double(matrix.columns.0.z), Double(matrix.columns.0.w)),
        SIMD4<Double>(Double(matrix.columns.1.x), Double(matrix.columns.1.y), Double(matrix.columns.1.z), Double(matrix.columns.1.w)),
        SIMD4<Double>(Double(matrix.columns.2.x), Double(matrix.columns.2.y), Double(matrix.columns.2.z), Double(matrix.columns.2.w)),
        SIMD4<Double>(Double(matrix.columns.3.x), Double(matrix.columns.3.y), Double(matrix.columns.3.z), Double(matrix.columns.3.w))
    ))
}

private func mdl_packed_joint_animation_info(_ animation: MDLPackedJointAnimation) -> [String: Any] {
    [
        "name": animation.name,
        "path": animation.path,
        "joint_paths": animation.jointPaths,
        "joint_count": animation.jointPaths.count,
    ]
}

private func mdl_animation_bind_component_info(_ component: MDLAnimationBindComponent) -> [String: Any] {
    [
        "has_skeleton": component.skeleton != nil,
        "has_joint_animation": component.jointAnimation != nil,
        "joint_paths": component.jointPaths as Any,
        "geometry_bind_transform": mdl_double_matrix_to_float_array(component.geometryBindTransform),
    ]
}

@_cdecl("mdl_packed_joint_animation_new")
public func mdl_packed_joint_animation_new(
    _ name: UnsafePointer<CChar>?,
    _ jointPaths: UnsafePointer<UnsafePointer<CChar>?>?,
    _ jointPathCount: UInt64,
    _ outAnimation: UnsafeMutablePointer<UnsafeMutableRawPointer?>?,
    _ outError: UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>?
) -> Int32 {
    mdl_run(outError) {
        guard let name, let outAnimation else {
            throw ModelIOBridgeError.invalidArgument("missing animation name or output pointer")
        }
        outAnimation.pointee = mdl_retain(
            MDLPackedJointAnimation(
                name: String(cString: name),
                jointPaths: mdl_string_array(jointPaths, count: jointPathCount)
            )
        )
    }
}

@_cdecl("mdl_packed_joint_animation_info_json")
public func mdl_packed_joint_animation_info_json(_ handle: UnsafeMutableRawPointer?) -> UnsafeMutablePointer<CChar>? {
    guard let animation = mdl_borrow_object(handle) as? MDLPackedJointAnimation else { return nil }
    return mdl_string(mdl_json_string(from: mdl_packed_joint_animation_info(animation)) ?? "{}")
}

@_cdecl("mdl_packed_joint_animation_translations")
public func mdl_packed_joint_animation_translations(_ handle: UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? {
    guard let animation = mdl_borrow_object(handle) as? MDLPackedJointAnimation else { return nil }
    return mdl_retain(animation.translations)
}

@_cdecl("mdl_packed_joint_animation_rotations")
public func mdl_packed_joint_animation_rotations(_ handle: UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? {
    guard let animation = mdl_borrow_object(handle) as? MDLPackedJointAnimation else { return nil }
    return mdl_retain(animation.rotations)
}

@_cdecl("mdl_packed_joint_animation_scales")
public func mdl_packed_joint_animation_scales(_ handle: UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? {
    guard let animation = mdl_borrow_object(handle) as? MDLPackedJointAnimation else { return nil }
    return mdl_retain(animation.scales)
}

@_cdecl("mdl_animation_bind_component_new")
public func mdl_animation_bind_component_new(
    _ outComponent: UnsafeMutablePointer<UnsafeMutableRawPointer?>?,
    _ outError: UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>?
) -> Int32 {
    mdl_run(outError) {
        guard let outComponent else {
            throw ModelIOBridgeError.invalidArgument("missing output animation bind component pointer")
        }
        outComponent.pointee = mdl_retain(MDLAnimationBindComponent())
    }
}

@_cdecl("mdl_animation_bind_component_info_json")
public func mdl_animation_bind_component_info_json(_ handle: UnsafeMutableRawPointer?) -> UnsafeMutablePointer<CChar>? {
    guard let component = mdl_borrow_object(handle) as? MDLAnimationBindComponent else { return nil }
    return mdl_string(mdl_json_string(from: mdl_animation_bind_component_info(component)) ?? "{}")
}

@_cdecl("mdl_animation_bind_component_set_skeleton")
public func mdl_animation_bind_component_set_skeleton(_ handle: UnsafeMutableRawPointer?, _ skeletonHandle: UnsafeMutableRawPointer?) {
    guard let component = mdl_borrow_object(handle) as? MDLAnimationBindComponent else { return }
    component.skeleton = mdl_borrow_object(skeletonHandle) as? MDLSkeleton
}

@_cdecl("mdl_animation_bind_component_skeleton")
public func mdl_animation_bind_component_skeleton(_ handle: UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? {
    guard let component = mdl_borrow_object(handle) as? MDLAnimationBindComponent,
          let skeleton = component.skeleton
    else {
        return nil
    }
    return mdl_retain(skeleton)
}

@_cdecl("mdl_animation_bind_component_set_packed_joint_animation")
public func mdl_animation_bind_component_set_packed_joint_animation(_ handle: UnsafeMutableRawPointer?, _ animationHandle: UnsafeMutableRawPointer?) {
    guard let component = mdl_borrow_object(handle) as? MDLAnimationBindComponent else { return }
    component.jointAnimation = mdl_borrow_object(animationHandle) as? MDLPackedJointAnimation
}

@_cdecl("mdl_animation_bind_component_packed_joint_animation")
public func mdl_animation_bind_component_packed_joint_animation(_ handle: UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? {
    guard let component = mdl_borrow_object(handle) as? MDLAnimationBindComponent,
          let animation = component.jointAnimation as? MDLPackedJointAnimation
    else {
        return nil
    }
    return mdl_retain(animation)
}

@_cdecl("mdl_animation_bind_component_set_joint_paths")
public func mdl_animation_bind_component_set_joint_paths(
    _ handle: UnsafeMutableRawPointer?,
    _ jointPaths: UnsafePointer<UnsafePointer<CChar>?>?,
    _ jointPathCount: UInt64
) {
    guard let component = mdl_borrow_object(handle) as? MDLAnimationBindComponent else { return }
    component.jointPaths = mdl_string_array(jointPaths, count: jointPathCount)
}

@_cdecl("mdl_animation_bind_component_set_geometry_bind_transform")
public func mdl_animation_bind_component_set_geometry_bind_transform(_ handle: UnsafeMutableRawPointer?, _ values: UnsafePointer<Float>?) {
    guard let component = mdl_borrow_object(handle) as? MDLAnimationBindComponent else { return }
    component.geometryBindTransform = mdl_float_array_to_double_matrix(values)
}