ocio_rs/transform/
log_camera.rs1use std::ffi::c_void;
2use std::ptr::NonNull;
3
4use crate::{Result, TransformDirection};
5use ocio_sys;
6
7pub struct LogCameraTransform {
9 pub(crate) handle: NonNull<c_void>,
10}
11
12impl LogCameraTransform {
13 pub fn create_with_lin_side_break(lin_side_break_values: &[f64; 3]) -> Result<Self> {
15 Self::create(lin_side_break_values)
16 }
17
18 pub fn create(lin_side_break_values: &[f64; 3]) -> Result<Self> {
20 crate::clear_last_error();
21 let handle = unsafe {
22 ocio_sys::ocio_log_camera_transform_create_with_lin_side_break(
23 lin_side_break_values.as_ptr(),
24 )
25 };
26 crate::handle_result(handle).map(|handle| Self { handle })
27 }
28
29 pub fn create_editable_copy(&self) -> Result<Self> {
31 crate::clear_last_error();
32 let handle = unsafe { ocio_sys::ocio_transform_create_editable_copy(self.handle.as_ptr()) };
33 crate::handle_result(handle).map(|handle| Self { handle })
34 }
35
36 pub fn base(&self) -> Result<f64> {
38 crate::clear_last_error();
39 let value = unsafe { ocio_sys::ocio_log_camera_transform_get_base(self.handle.as_ptr()) };
40 crate::ocio_call_status()?;
41 Ok(value)
42 }
43
44 pub fn set_base(&self, base: f64) -> Result<()> {
46 crate::clear_last_error();
47 unsafe {
48 ocio_sys::ocio_log_camera_transform_set_base(self.handle.as_ptr(), base);
49 }
50 crate::ocio_call_status()
51 }
52
53 pub fn log_side_slope_value(&self) -> Result<[f64; 3]> {
55 let mut v = [0.0f64; 3];
56 crate::clear_last_error();
57 unsafe {
58 ocio_sys::ocio_log_camera_transform_get_log_side_slope_value(
59 self.handle.as_ptr(),
60 v.as_mut_ptr(),
61 );
62 }
63 crate::ocio_call_status()?;
64 Ok(v)
65 }
66
67 pub fn set_log_side_slope_value(&self, values: &[f64; 3]) -> Result<()> {
69 crate::clear_last_error();
70 unsafe {
71 ocio_sys::ocio_log_camera_transform_set_log_side_slope_value(
72 self.handle.as_ptr(),
73 values.as_ptr(),
74 );
75 }
76 crate::ocio_call_status()
77 }
78
79 pub fn log_side_offset_value(&self) -> Result<[f64; 3]> {
81 let mut v = [0.0f64; 3];
82 crate::clear_last_error();
83 unsafe {
84 ocio_sys::ocio_log_camera_transform_get_log_side_offset_value(
85 self.handle.as_ptr(),
86 v.as_mut_ptr(),
87 );
88 }
89 crate::ocio_call_status()?;
90 Ok(v)
91 }
92
93 pub fn set_log_side_offset_value(&self, values: &[f64; 3]) -> Result<()> {
95 crate::clear_last_error();
96 unsafe {
97 ocio_sys::ocio_log_camera_transform_set_log_side_offset_value(
98 self.handle.as_ptr(),
99 values.as_ptr(),
100 );
101 }
102 crate::ocio_call_status()
103 }
104
105 pub fn lin_side_slope_value(&self) -> Result<[f64; 3]> {
107 let mut v = [0.0f64; 3];
108 crate::clear_last_error();
109 unsafe {
110 ocio_sys::ocio_log_camera_transform_get_lin_side_slope_value(
111 self.handle.as_ptr(),
112 v.as_mut_ptr(),
113 );
114 }
115 crate::ocio_call_status()?;
116 Ok(v)
117 }
118
119 pub fn set_lin_side_slope_value(&self, values: &[f64; 3]) -> Result<()> {
121 crate::clear_last_error();
122 unsafe {
123 ocio_sys::ocio_log_camera_transform_set_lin_side_slope_value(
124 self.handle.as_ptr(),
125 values.as_ptr(),
126 );
127 }
128 crate::ocio_call_status()
129 }
130
131 pub fn lin_side_offset_value(&self) -> Result<[f64; 3]> {
133 let mut v = [0.0f64; 3];
134 crate::clear_last_error();
135 unsafe {
136 ocio_sys::ocio_log_camera_transform_get_lin_side_offset_value(
137 self.handle.as_ptr(),
138 v.as_mut_ptr(),
139 );
140 }
141 crate::ocio_call_status()?;
142 Ok(v)
143 }
144
145 pub fn set_lin_side_offset_value(&self, values: &[f64; 3]) -> Result<()> {
147 crate::clear_last_error();
148 unsafe {
149 ocio_sys::ocio_log_camera_transform_set_lin_side_offset_value(
150 self.handle.as_ptr(),
151 values.as_ptr(),
152 );
153 }
154 crate::ocio_call_status()
155 }
156
157 pub fn lin_side_break_value(&self) -> Result<[f64; 3]> {
159 let mut v = [0.0f64; 3];
160 crate::clear_last_error();
161 unsafe {
162 ocio_sys::ocio_log_camera_transform_get_lin_side_break_value(
163 self.handle.as_ptr(),
164 v.as_mut_ptr(),
165 );
166 }
167 crate::ocio_call_status()?;
168 Ok(v)
169 }
170
171 pub fn set_lin_side_break_value(&self, values: &[f64; 3]) -> Result<()> {
173 crate::clear_last_error();
174 unsafe {
175 ocio_sys::ocio_log_camera_transform_set_lin_side_break_value(
176 self.handle.as_ptr(),
177 values.as_ptr(),
178 );
179 }
180 crate::ocio_call_status()
181 }
182
183 pub fn linear_slope_value(&self) -> Result<Option<[f64; 3]>> {
185 let mut v = [0.0f64; 3];
186 crate::clear_last_error();
187 let ok = unsafe {
188 ocio_sys::ocio_log_camera_transform_get_linear_slope_value(
189 self.handle.as_ptr(),
190 v.as_mut_ptr(),
191 )
192 };
193 crate::ocio_call_status()?;
194 if ok {
195 Ok(Some(v))
196 } else {
197 Ok(None)
198 }
199 }
200
201 pub fn set_linear_slope_value(&self, values: &[f64; 3]) -> Result<()> {
203 crate::clear_last_error();
204 unsafe {
205 ocio_sys::ocio_log_camera_transform_set_linear_slope_value(
206 self.handle.as_ptr(),
207 values.as_ptr(),
208 );
209 }
210 crate::ocio_call_status()
211 }
212
213 pub fn unset_linear_slope_value(&self) -> Result<()> {
215 crate::clear_last_error();
216 unsafe {
217 ocio_sys::ocio_log_camera_transform_unset_linear_slope_value(self.handle.as_ptr());
218 }
219 crate::ocio_call_status()
220 }
221
222 pub fn direction(&self) -> TransformDirection {
224 let dir =
225 unsafe { ocio_sys::ocio_log_camera_transform_get_direction(self.handle.as_ptr()) };
226 match dir {
227 1 => TransformDirection::Inverse,
228 _ => TransformDirection::Forward,
229 }
230 }
231
232 pub fn set_direction(&self, direction: TransformDirection) {
234 self.try_set_direction(direction)
235 .expect("failed to set log camera transform direction");
236 }
237
238 pub fn try_set_direction(&self, direction: TransformDirection) -> Result<()> {
240 crate::clear_last_error();
241 unsafe {
242 ocio_sys::ocio_log_camera_transform_set_direction(
243 self.handle.as_ptr(),
244 direction as i32,
245 );
246 }
247 crate::ocio_call_status()
248 }
249
250 pub fn format_metadata(&self) -> Option<crate::FormatMetadata> {
252 let handle = unsafe { ocio_sys::ocio_transform_get_format_metadata(self.handle.as_ptr()) };
253 NonNull::new(handle).map(|h| crate::FormatMetadata { handle: h })
254 }
255
256 #[deprecated(since = "0.2.0", note = "compat alias; prefer format_metadata()")]
257 pub fn format_metadata_v1(&self) -> Option<crate::FormatMetadata> {
258 self.format_metadata()
259 }
260
261 #[deprecated(since = "0.2.0", note = "compat alias; prefer format_metadata()")]
262 pub fn format_metadata_v2(&self) -> Option<crate::FormatMetadata> {
263 self.format_metadata()
264 }
265
266 pub fn equals(&self, other: &Self) -> bool {
268 unsafe {
269 ocio_sys::ocio_log_camera_transform_equals(self.handle.as_ptr(), other.handle.as_ptr())
270 }
271 }
272}
273
274impl Drop for LogCameraTransform {
275 fn drop(&mut self) {
276 unsafe { ocio_sys::ocio_log_camera_transform_destroy(self.handle.as_ptr()) };
277 }
278}
279
280#[cfg(test)]
281mod tests {
282 use super::*;
283
284 #[test]
285 fn create_log_camera_transform() {
286 let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]);
287 assert!(t.is_ok());
288 }
289
290 #[test]
291 fn log_camera_transform_methods_no_crash() {
292 let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
293 let _ = t.base();
294 let _ = t.log_side_slope_value();
295 let _ = t.log_side_offset_value();
296 let _ = t.lin_side_slope_value();
297 let _ = t.lin_side_offset_value();
298 let _ = t.lin_side_break_value();
299 let _ = t.linear_slope_value();
300 }
301
302 #[test]
303 fn set_values_no_crash() {
304 let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
305 let _ = t.set_base(10.0);
306 let _ = t.set_log_side_slope_value(&[1.0, 1.0, 1.0]);
307 let _ = t.set_log_side_offset_value(&[0.0, 0.0, 0.0]);
308 let _ = t.set_lin_side_slope_value(&[1.0, 1.0, 1.0]);
309 let _ = t.set_lin_side_offset_value(&[0.0, 0.0, 0.0]);
310 let _ = t.set_lin_side_break_value(&[0.01, 0.01, 0.01]);
311 let _ = t.set_linear_slope_value(&[1.0, 1.0, 1.0]);
312 let _ = t.unset_linear_slope_value();
313 }
314
315 #[test]
316 fn create_editable_copy_no_crash() {
317 let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
318 let _ = t.create_editable_copy();
319 }
320
321 #[test]
322 fn equals_no_crash() {
323 let a = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
324 let b = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
325 let _ = a.equals(&b);
326 }
327
328 #[test]
329 fn direction_no_crash() {
330 let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
331 let _ = t.direction();
332 t.try_set_direction(TransformDirection::Inverse).unwrap();
333 }
334
335 #[test]
336 fn format_metadata_no_crash() {
337 let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
338 let _ = t.format_metadata();
339 }
340}