1use core::ptr::NonNull;
4use objc2::__framework_prelude::*;
5#[cfg(feature = "objc2-core-foundation")]
6use objc2_core_foundation::*;
7use objc2_foundation::*;
8
9use crate::*;
10
11#[cfg(feature = "objc2-core-foundation")]
13#[repr(C)]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub struct CATransform3D {
16 pub m11: CGFloat,
17 pub m12: CGFloat,
18 pub m13: CGFloat,
19 pub m14: CGFloat,
20 pub m21: CGFloat,
21 pub m22: CGFloat,
22 pub m23: CGFloat,
23 pub m24: CGFloat,
24 pub m31: CGFloat,
25 pub m32: CGFloat,
26 pub m33: CGFloat,
27 pub m34: CGFloat,
28 pub m41: CGFloat,
29 pub m42: CGFloat,
30 pub m43: CGFloat,
31 pub m44: CGFloat,
32}
33
34#[cfg(feature = "objc2-core-foundation")]
35unsafe impl Encode for CATransform3D {
36 const ENCODING: Encoding = Encoding::Struct(
37 "CATransform3D",
38 &[
39 <CGFloat>::ENCODING,
40 <CGFloat>::ENCODING,
41 <CGFloat>::ENCODING,
42 <CGFloat>::ENCODING,
43 <CGFloat>::ENCODING,
44 <CGFloat>::ENCODING,
45 <CGFloat>::ENCODING,
46 <CGFloat>::ENCODING,
47 <CGFloat>::ENCODING,
48 <CGFloat>::ENCODING,
49 <CGFloat>::ENCODING,
50 <CGFloat>::ENCODING,
51 <CGFloat>::ENCODING,
52 <CGFloat>::ENCODING,
53 <CGFloat>::ENCODING,
54 <CGFloat>::ENCODING,
55 ],
56 );
57}
58
59#[cfg(feature = "objc2-core-foundation")]
60unsafe impl RefEncode for CATransform3D {
61 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
62}
63
64extern "C" {
65 #[cfg(feature = "objc2-core-foundation")]
67 pub static CATransform3DIdentity: CATransform3D;
68}
69
70#[cfg(feature = "objc2-core-foundation")]
71impl CATransform3D {
72 #[doc(alias = "CATransform3DIsIdentity")]
73 #[cfg(feature = "objc2-core-foundation")]
74 #[inline]
75 pub fn is_identity(self: CATransform3D) -> bool {
76 extern "C-unwind" {
77 fn CATransform3DIsIdentity(t: CATransform3D) -> bool;
78 }
79 unsafe { CATransform3DIsIdentity(self) }
80 }
81
82 #[doc(alias = "CATransform3DEqualToTransform")]
83 #[cfg(feature = "objc2-core-foundation")]
84 #[inline]
85 pub fn equal_to_transform(self: CATransform3D, b: CATransform3D) -> bool {
86 extern "C-unwind" {
87 fn CATransform3DEqualToTransform(a: CATransform3D, b: CATransform3D) -> bool;
88 }
89 unsafe { CATransform3DEqualToTransform(self, b) }
90 }
91
92 #[doc(alias = "CATransform3DMakeTranslation")]
93 #[cfg(feature = "objc2-core-foundation")]
94 #[inline]
95 pub fn new_translation(tx: CGFloat, ty: CGFloat, tz: CGFloat) -> CATransform3D {
96 extern "C-unwind" {
97 fn CATransform3DMakeTranslation(tx: CGFloat, ty: CGFloat, tz: CGFloat)
98 -> CATransform3D;
99 }
100 unsafe { CATransform3DMakeTranslation(tx, ty, tz) }
101 }
102
103 #[doc(alias = "CATransform3DMakeScale")]
104 #[cfg(feature = "objc2-core-foundation")]
105 #[inline]
106 pub fn new_scale(sx: CGFloat, sy: CGFloat, sz: CGFloat) -> CATransform3D {
107 extern "C-unwind" {
108 fn CATransform3DMakeScale(sx: CGFloat, sy: CGFloat, sz: CGFloat) -> CATransform3D;
109 }
110 unsafe { CATransform3DMakeScale(sx, sy, sz) }
111 }
112
113 #[doc(alias = "CATransform3DMakeRotation")]
114 #[cfg(feature = "objc2-core-foundation")]
115 #[inline]
116 pub fn new_rotation(angle: CGFloat, x: CGFloat, y: CGFloat, z: CGFloat) -> CATransform3D {
117 extern "C-unwind" {
118 fn CATransform3DMakeRotation(
119 angle: CGFloat,
120 x: CGFloat,
121 y: CGFloat,
122 z: CGFloat,
123 ) -> CATransform3D;
124 }
125 unsafe { CATransform3DMakeRotation(angle, x, y, z) }
126 }
127
128 #[doc(alias = "CATransform3DTranslate")]
129 #[cfg(feature = "objc2-core-foundation")]
130 #[inline]
131 pub fn translate(self: CATransform3D, tx: CGFloat, ty: CGFloat, tz: CGFloat) -> CATransform3D {
132 extern "C-unwind" {
133 fn CATransform3DTranslate(
134 t: CATransform3D,
135 tx: CGFloat,
136 ty: CGFloat,
137 tz: CGFloat,
138 ) -> CATransform3D;
139 }
140 unsafe { CATransform3DTranslate(self, tx, ty, tz) }
141 }
142
143 #[doc(alias = "CATransform3DScale")]
144 #[cfg(feature = "objc2-core-foundation")]
145 #[inline]
146 pub fn scale(self: CATransform3D, sx: CGFloat, sy: CGFloat, sz: CGFloat) -> CATransform3D {
147 extern "C-unwind" {
148 fn CATransform3DScale(
149 t: CATransform3D,
150 sx: CGFloat,
151 sy: CGFloat,
152 sz: CGFloat,
153 ) -> CATransform3D;
154 }
155 unsafe { CATransform3DScale(self, sx, sy, sz) }
156 }
157
158 #[doc(alias = "CATransform3DRotate")]
159 #[cfg(feature = "objc2-core-foundation")]
160 #[inline]
161 pub fn rotate(
162 self: CATransform3D,
163 angle: CGFloat,
164 x: CGFloat,
165 y: CGFloat,
166 z: CGFloat,
167 ) -> CATransform3D {
168 extern "C-unwind" {
169 fn CATransform3DRotate(
170 t: CATransform3D,
171 angle: CGFloat,
172 x: CGFloat,
173 y: CGFloat,
174 z: CGFloat,
175 ) -> CATransform3D;
176 }
177 unsafe { CATransform3DRotate(self, angle, x, y, z) }
178 }
179
180 #[doc(alias = "CATransform3DConcat")]
181 #[cfg(feature = "objc2-core-foundation")]
182 #[inline]
183 pub fn concat(self: CATransform3D, b: CATransform3D) -> CATransform3D {
184 extern "C-unwind" {
185 fn CATransform3DConcat(a: CATransform3D, b: CATransform3D) -> CATransform3D;
186 }
187 unsafe { CATransform3DConcat(self, b) }
188 }
189
190 #[doc(alias = "CATransform3DInvert")]
191 #[cfg(feature = "objc2-core-foundation")]
192 #[inline]
193 pub fn invert(self: CATransform3D) -> CATransform3D {
194 extern "C-unwind" {
195 fn CATransform3DInvert(t: CATransform3D) -> CATransform3D;
196 }
197 unsafe { CATransform3DInvert(self) }
198 }
199
200 #[doc(alias = "CATransform3DMakeAffineTransform")]
201 #[cfg(feature = "objc2-core-foundation")]
202 #[inline]
203 pub fn new_affine_transform(m: CGAffineTransform) -> CATransform3D {
204 extern "C-unwind" {
205 fn CATransform3DMakeAffineTransform(m: CGAffineTransform) -> CATransform3D;
206 }
207 unsafe { CATransform3DMakeAffineTransform(m) }
208 }
209
210 #[doc(alias = "CATransform3DIsAffine")]
211 #[cfg(feature = "objc2-core-foundation")]
212 #[inline]
213 pub fn is_affine(self: CATransform3D) -> bool {
214 extern "C-unwind" {
215 fn CATransform3DIsAffine(t: CATransform3D) -> bool;
216 }
217 unsafe { CATransform3DIsAffine(self) }
218 }
219
220 #[doc(alias = "CATransform3DGetAffineTransform")]
221 #[cfg(feature = "objc2-core-foundation")]
222 #[inline]
223 pub fn affine_transform(self: CATransform3D) -> CGAffineTransform {
224 extern "C-unwind" {
225 fn CATransform3DGetAffineTransform(t: CATransform3D) -> CGAffineTransform;
226 }
227 unsafe { CATransform3DGetAffineTransform(self) }
228 }
229}
230
231mod private_NSValueCATransform3DAdditions {
232 pub trait Sealed {}
233}
234
235#[doc(alias = "CATransform3DAdditions")]
237pub unsafe trait NSValueCATransform3DAdditions:
238 ClassType + Sized + private_NSValueCATransform3DAdditions::Sealed
239{
240 extern_methods!(
241 #[cfg(feature = "objc2-core-foundation")]
242 #[unsafe(method(valueWithCATransform3D:))]
243 #[unsafe(method_family = none)]
244 unsafe fn valueWithCATransform3D(t: CATransform3D) -> Retained<NSValue>;
245
246 #[cfg(feature = "objc2-core-foundation")]
247 #[unsafe(method(CATransform3DValue))]
248 #[unsafe(method_family = none)]
249 unsafe fn CATransform3DValue(&self) -> CATransform3D;
250 );
251}
252
253impl private_NSValueCATransform3DAdditions::Sealed for NSValue {}
254unsafe impl NSValueCATransform3DAdditions for NSValue {}
255
256#[cfg(feature = "objc2-core-foundation")]
257#[deprecated = "renamed to `CATransform3D::is_identity`"]
258#[inline]
259pub extern "C-unwind" fn CATransform3DIsIdentity(t: CATransform3D) -> bool {
260 extern "C-unwind" {
261 fn CATransform3DIsIdentity(t: CATransform3D) -> bool;
262 }
263 unsafe { CATransform3DIsIdentity(t) }
264}
265
266#[cfg(feature = "objc2-core-foundation")]
267#[deprecated = "renamed to `CATransform3D::equal_to_transform`"]
268#[inline]
269pub extern "C-unwind" fn CATransform3DEqualToTransform(a: CATransform3D, b: CATransform3D) -> bool {
270 extern "C-unwind" {
271 fn CATransform3DEqualToTransform(a: CATransform3D, b: CATransform3D) -> bool;
272 }
273 unsafe { CATransform3DEqualToTransform(a, b) }
274}
275
276#[cfg(feature = "objc2-core-foundation")]
277#[deprecated = "renamed to `CATransform3D::new_translation`"]
278#[inline]
279pub extern "C-unwind" fn CATransform3DMakeTranslation(
280 tx: CGFloat,
281 ty: CGFloat,
282 tz: CGFloat,
283) -> CATransform3D {
284 extern "C-unwind" {
285 fn CATransform3DMakeTranslation(tx: CGFloat, ty: CGFloat, tz: CGFloat) -> CATransform3D;
286 }
287 unsafe { CATransform3DMakeTranslation(tx, ty, tz) }
288}
289
290#[cfg(feature = "objc2-core-foundation")]
291#[deprecated = "renamed to `CATransform3D::new_scale`"]
292#[inline]
293pub extern "C-unwind" fn CATransform3DMakeScale(
294 sx: CGFloat,
295 sy: CGFloat,
296 sz: CGFloat,
297) -> CATransform3D {
298 extern "C-unwind" {
299 fn CATransform3DMakeScale(sx: CGFloat, sy: CGFloat, sz: CGFloat) -> CATransform3D;
300 }
301 unsafe { CATransform3DMakeScale(sx, sy, sz) }
302}
303
304#[cfg(feature = "objc2-core-foundation")]
305#[deprecated = "renamed to `CATransform3D::new_rotation`"]
306#[inline]
307pub extern "C-unwind" fn CATransform3DMakeRotation(
308 angle: CGFloat,
309 x: CGFloat,
310 y: CGFloat,
311 z: CGFloat,
312) -> CATransform3D {
313 extern "C-unwind" {
314 fn CATransform3DMakeRotation(
315 angle: CGFloat,
316 x: CGFloat,
317 y: CGFloat,
318 z: CGFloat,
319 ) -> CATransform3D;
320 }
321 unsafe { CATransform3DMakeRotation(angle, x, y, z) }
322}
323
324#[cfg(feature = "objc2-core-foundation")]
325#[deprecated = "renamed to `CATransform3D::translate`"]
326#[inline]
327pub extern "C-unwind" fn CATransform3DTranslate(
328 t: CATransform3D,
329 tx: CGFloat,
330 ty: CGFloat,
331 tz: CGFloat,
332) -> CATransform3D {
333 extern "C-unwind" {
334 fn CATransform3DTranslate(
335 t: CATransform3D,
336 tx: CGFloat,
337 ty: CGFloat,
338 tz: CGFloat,
339 ) -> CATransform3D;
340 }
341 unsafe { CATransform3DTranslate(t, tx, ty, tz) }
342}
343
344#[cfg(feature = "objc2-core-foundation")]
345#[deprecated = "renamed to `CATransform3D::scale`"]
346#[inline]
347pub extern "C-unwind" fn CATransform3DScale(
348 t: CATransform3D,
349 sx: CGFloat,
350 sy: CGFloat,
351 sz: CGFloat,
352) -> CATransform3D {
353 extern "C-unwind" {
354 fn CATransform3DScale(
355 t: CATransform3D,
356 sx: CGFloat,
357 sy: CGFloat,
358 sz: CGFloat,
359 ) -> CATransform3D;
360 }
361 unsafe { CATransform3DScale(t, sx, sy, sz) }
362}
363
364#[cfg(feature = "objc2-core-foundation")]
365#[deprecated = "renamed to `CATransform3D::rotate`"]
366#[inline]
367pub extern "C-unwind" fn CATransform3DRotate(
368 t: CATransform3D,
369 angle: CGFloat,
370 x: CGFloat,
371 y: CGFloat,
372 z: CGFloat,
373) -> CATransform3D {
374 extern "C-unwind" {
375 fn CATransform3DRotate(
376 t: CATransform3D,
377 angle: CGFloat,
378 x: CGFloat,
379 y: CGFloat,
380 z: CGFloat,
381 ) -> CATransform3D;
382 }
383 unsafe { CATransform3DRotate(t, angle, x, y, z) }
384}
385
386#[cfg(feature = "objc2-core-foundation")]
387#[deprecated = "renamed to `CATransform3D::concat`"]
388#[inline]
389pub extern "C-unwind" fn CATransform3DConcat(a: CATransform3D, b: CATransform3D) -> CATransform3D {
390 extern "C-unwind" {
391 fn CATransform3DConcat(a: CATransform3D, b: CATransform3D) -> CATransform3D;
392 }
393 unsafe { CATransform3DConcat(a, b) }
394}
395
396#[cfg(feature = "objc2-core-foundation")]
397#[deprecated = "renamed to `CATransform3D::invert`"]
398#[inline]
399pub extern "C-unwind" fn CATransform3DInvert(t: CATransform3D) -> CATransform3D {
400 extern "C-unwind" {
401 fn CATransform3DInvert(t: CATransform3D) -> CATransform3D;
402 }
403 unsafe { CATransform3DInvert(t) }
404}
405
406#[cfg(feature = "objc2-core-foundation")]
407#[deprecated = "renamed to `CATransform3D::new_affine_transform`"]
408#[inline]
409pub extern "C-unwind" fn CATransform3DMakeAffineTransform(m: CGAffineTransform) -> CATransform3D {
410 extern "C-unwind" {
411 fn CATransform3DMakeAffineTransform(m: CGAffineTransform) -> CATransform3D;
412 }
413 unsafe { CATransform3DMakeAffineTransform(m) }
414}
415
416#[cfg(feature = "objc2-core-foundation")]
417#[deprecated = "renamed to `CATransform3D::is_affine`"]
418#[inline]
419pub extern "C-unwind" fn CATransform3DIsAffine(t: CATransform3D) -> bool {
420 extern "C-unwind" {
421 fn CATransform3DIsAffine(t: CATransform3D) -> bool;
422 }
423 unsafe { CATransform3DIsAffine(t) }
424}
425
426#[cfg(feature = "objc2-core-foundation")]
427#[deprecated = "renamed to `CATransform3D::affine_transform`"]
428#[inline]
429pub extern "C-unwind" fn CATransform3DGetAffineTransform(t: CATransform3D) -> CGAffineTransform {
430 extern "C-unwind" {
431 fn CATransform3DGetAffineTransform(t: CATransform3D) -> CGAffineTransform;
432 }
433 unsafe { CATransform3DGetAffineTransform(t) }
434}