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) -> 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, 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, 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, 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(self, angle: CGFloat, x: CGFloat, y: CGFloat, z: CGFloat) -> CATransform3D {
162 extern "C-unwind" {
163 fn CATransform3DRotate(
164 t: CATransform3D,
165 angle: CGFloat,
166 x: CGFloat,
167 y: CGFloat,
168 z: CGFloat,
169 ) -> CATransform3D;
170 }
171 unsafe { CATransform3DRotate(self, angle, x, y, z) }
172 }
173
174 #[doc(alias = "CATransform3DConcat")]
175 #[cfg(feature = "objc2-core-foundation")]
176 #[inline]
177 pub fn concat(self, b: CATransform3D) -> CATransform3D {
178 extern "C-unwind" {
179 fn CATransform3DConcat(a: CATransform3D, b: CATransform3D) -> CATransform3D;
180 }
181 unsafe { CATransform3DConcat(self, b) }
182 }
183
184 #[doc(alias = "CATransform3DInvert")]
185 #[cfg(feature = "objc2-core-foundation")]
186 #[inline]
187 pub fn invert(self) -> CATransform3D {
188 extern "C-unwind" {
189 fn CATransform3DInvert(t: CATransform3D) -> CATransform3D;
190 }
191 unsafe { CATransform3DInvert(self) }
192 }
193
194 #[doc(alias = "CATransform3DMakeAffineTransform")]
195 #[cfg(feature = "objc2-core-foundation")]
196 #[inline]
197 pub fn new_affine_transform(m: CGAffineTransform) -> CATransform3D {
198 extern "C-unwind" {
199 fn CATransform3DMakeAffineTransform(m: CGAffineTransform) -> CATransform3D;
200 }
201 unsafe { CATransform3DMakeAffineTransform(m) }
202 }
203
204 #[doc(alias = "CATransform3DIsAffine")]
205 #[cfg(feature = "objc2-core-foundation")]
206 #[inline]
207 pub fn is_affine(self) -> bool {
208 extern "C-unwind" {
209 fn CATransform3DIsAffine(t: CATransform3D) -> bool;
210 }
211 unsafe { CATransform3DIsAffine(self) }
212 }
213
214 #[doc(alias = "CATransform3DGetAffineTransform")]
215 #[cfg(feature = "objc2-core-foundation")]
216 #[inline]
217 pub fn affine_transform(self) -> CGAffineTransform {
218 extern "C-unwind" {
219 fn CATransform3DGetAffineTransform(t: CATransform3D) -> CGAffineTransform;
220 }
221 unsafe { CATransform3DGetAffineTransform(self) }
222 }
223}
224
225mod private_NSValueCATransform3DAdditions {
226 pub trait Sealed {}
227}
228
229#[doc(alias = "CATransform3DAdditions")]
231pub unsafe trait NSValueCATransform3DAdditions:
232 ClassType + Sized + private_NSValueCATransform3DAdditions::Sealed
233{
234 extern_methods!(
235 #[cfg(feature = "objc2-core-foundation")]
236 #[unsafe(method(valueWithCATransform3D:))]
237 #[unsafe(method_family = none)]
238 unsafe fn valueWithCATransform3D(t: CATransform3D) -> Retained<NSValue>;
239
240 #[cfg(feature = "objc2-core-foundation")]
241 #[unsafe(method(CATransform3DValue))]
242 #[unsafe(method_family = none)]
243 unsafe fn CATransform3DValue(&self) -> CATransform3D;
244 );
245}
246
247impl private_NSValueCATransform3DAdditions::Sealed for NSValue {}
248unsafe impl NSValueCATransform3DAdditions for NSValue {}
249
250#[cfg(feature = "objc2-core-foundation")]
251#[deprecated = "renamed to `CATransform3D::is_identity`"]
252#[inline]
253pub extern "C-unwind" fn CATransform3DIsIdentity(t: CATransform3D) -> bool {
254 extern "C-unwind" {
255 fn CATransform3DIsIdentity(t: CATransform3D) -> bool;
256 }
257 unsafe { CATransform3DIsIdentity(t) }
258}
259
260#[cfg(feature = "objc2-core-foundation")]
261#[deprecated = "renamed to `CATransform3D::equal_to_transform`"]
262#[inline]
263pub extern "C-unwind" fn CATransform3DEqualToTransform(a: CATransform3D, b: CATransform3D) -> bool {
264 extern "C-unwind" {
265 fn CATransform3DEqualToTransform(a: CATransform3D, b: CATransform3D) -> bool;
266 }
267 unsafe { CATransform3DEqualToTransform(a, b) }
268}
269
270#[cfg(feature = "objc2-core-foundation")]
271#[deprecated = "renamed to `CATransform3D::new_translation`"]
272#[inline]
273pub extern "C-unwind" fn CATransform3DMakeTranslation(
274 tx: CGFloat,
275 ty: CGFloat,
276 tz: CGFloat,
277) -> CATransform3D {
278 extern "C-unwind" {
279 fn CATransform3DMakeTranslation(tx: CGFloat, ty: CGFloat, tz: CGFloat) -> CATransform3D;
280 }
281 unsafe { CATransform3DMakeTranslation(tx, ty, tz) }
282}
283
284#[cfg(feature = "objc2-core-foundation")]
285#[deprecated = "renamed to `CATransform3D::new_scale`"]
286#[inline]
287pub extern "C-unwind" fn CATransform3DMakeScale(
288 sx: CGFloat,
289 sy: CGFloat,
290 sz: CGFloat,
291) -> CATransform3D {
292 extern "C-unwind" {
293 fn CATransform3DMakeScale(sx: CGFloat, sy: CGFloat, sz: CGFloat) -> CATransform3D;
294 }
295 unsafe { CATransform3DMakeScale(sx, sy, sz) }
296}
297
298#[cfg(feature = "objc2-core-foundation")]
299#[deprecated = "renamed to `CATransform3D::new_rotation`"]
300#[inline]
301pub extern "C-unwind" fn CATransform3DMakeRotation(
302 angle: CGFloat,
303 x: CGFloat,
304 y: CGFloat,
305 z: CGFloat,
306) -> CATransform3D {
307 extern "C-unwind" {
308 fn CATransform3DMakeRotation(
309 angle: CGFloat,
310 x: CGFloat,
311 y: CGFloat,
312 z: CGFloat,
313 ) -> CATransform3D;
314 }
315 unsafe { CATransform3DMakeRotation(angle, x, y, z) }
316}
317
318#[cfg(feature = "objc2-core-foundation")]
319#[deprecated = "renamed to `CATransform3D::translate`"]
320#[inline]
321pub extern "C-unwind" fn CATransform3DTranslate(
322 t: CATransform3D,
323 tx: CGFloat,
324 ty: CGFloat,
325 tz: CGFloat,
326) -> CATransform3D {
327 extern "C-unwind" {
328 fn CATransform3DTranslate(
329 t: CATransform3D,
330 tx: CGFloat,
331 ty: CGFloat,
332 tz: CGFloat,
333 ) -> CATransform3D;
334 }
335 unsafe { CATransform3DTranslate(t, tx, ty, tz) }
336}
337
338#[cfg(feature = "objc2-core-foundation")]
339#[deprecated = "renamed to `CATransform3D::scale`"]
340#[inline]
341pub extern "C-unwind" fn CATransform3DScale(
342 t: CATransform3D,
343 sx: CGFloat,
344 sy: CGFloat,
345 sz: CGFloat,
346) -> CATransform3D {
347 extern "C-unwind" {
348 fn CATransform3DScale(
349 t: CATransform3D,
350 sx: CGFloat,
351 sy: CGFloat,
352 sz: CGFloat,
353 ) -> CATransform3D;
354 }
355 unsafe { CATransform3DScale(t, sx, sy, sz) }
356}
357
358#[cfg(feature = "objc2-core-foundation")]
359#[deprecated = "renamed to `CATransform3D::rotate`"]
360#[inline]
361pub extern "C-unwind" fn CATransform3DRotate(
362 t: CATransform3D,
363 angle: CGFloat,
364 x: CGFloat,
365 y: CGFloat,
366 z: CGFloat,
367) -> CATransform3D {
368 extern "C-unwind" {
369 fn CATransform3DRotate(
370 t: CATransform3D,
371 angle: CGFloat,
372 x: CGFloat,
373 y: CGFloat,
374 z: CGFloat,
375 ) -> CATransform3D;
376 }
377 unsafe { CATransform3DRotate(t, angle, x, y, z) }
378}
379
380#[cfg(feature = "objc2-core-foundation")]
381#[deprecated = "renamed to `CATransform3D::concat`"]
382#[inline]
383pub extern "C-unwind" fn CATransform3DConcat(a: CATransform3D, b: CATransform3D) -> CATransform3D {
384 extern "C-unwind" {
385 fn CATransform3DConcat(a: CATransform3D, b: CATransform3D) -> CATransform3D;
386 }
387 unsafe { CATransform3DConcat(a, b) }
388}
389
390#[cfg(feature = "objc2-core-foundation")]
391#[deprecated = "renamed to `CATransform3D::invert`"]
392#[inline]
393pub extern "C-unwind" fn CATransform3DInvert(t: CATransform3D) -> CATransform3D {
394 extern "C-unwind" {
395 fn CATransform3DInvert(t: CATransform3D) -> CATransform3D;
396 }
397 unsafe { CATransform3DInvert(t) }
398}
399
400#[cfg(feature = "objc2-core-foundation")]
401#[deprecated = "renamed to `CATransform3D::new_affine_transform`"]
402#[inline]
403pub extern "C-unwind" fn CATransform3DMakeAffineTransform(m: CGAffineTransform) -> CATransform3D {
404 extern "C-unwind" {
405 fn CATransform3DMakeAffineTransform(m: CGAffineTransform) -> CATransform3D;
406 }
407 unsafe { CATransform3DMakeAffineTransform(m) }
408}
409
410#[cfg(feature = "objc2-core-foundation")]
411#[deprecated = "renamed to `CATransform3D::is_affine`"]
412#[inline]
413pub extern "C-unwind" fn CATransform3DIsAffine(t: CATransform3D) -> bool {
414 extern "C-unwind" {
415 fn CATransform3DIsAffine(t: CATransform3D) -> bool;
416 }
417 unsafe { CATransform3DIsAffine(t) }
418}
419
420#[cfg(feature = "objc2-core-foundation")]
421#[deprecated = "renamed to `CATransform3D::affine_transform`"]
422#[inline]
423pub extern "C-unwind" fn CATransform3DGetAffineTransform(t: CATransform3D) -> CGAffineTransform {
424 extern "C-unwind" {
425 fn CATransform3DGetAffineTransform(t: CATransform3D) -> CGAffineTransform;
426 }
427 unsafe { CATransform3DGetAffineTransform(t) }
428}