hapi_rs/parameter/
base.rs

1use crate::Result;
2use crate::ffi::enums::ChoiceListType;
3use crate::ffi::{KeyFrame, ParmChoiceInfo, ParmInfo};
4use crate::node::{NodeHandle, ParmType};
5use crate::session::Session;
6use std::borrow::Cow;
7use std::ffi::{CStr, CString};
8
9use super::Parameter;
10
11/// Common trait for parameters
12pub trait ParmBaseTrait {
13    #[inline]
14    fn name(&self) -> Result<Cow<'_, str>> {
15        let inner = self.inner();
16        match inner.info.2.as_ref() {
17            None => inner.info.name().map(Cow::Owned),
18            Some(c_name) => Ok(c_name.to_string_lossy()),
19        }
20    }
21
22    #[inline]
23    fn session(&self) -> &Session {
24        &self.info().1
25    }
26
27    #[inline]
28    fn node(&self) -> NodeHandle {
29        self.inner().node
30    }
31
32    #[inline]
33    fn size(&self) -> i32 {
34        self.info().size()
35    }
36
37    #[inline]
38    fn info(&self) -> &ParmInfo {
39        &self.inner().info
40    }
41
42    /// Update the internal parameter metadata if Houdini parameter changed,
43    /// for example children added to a multi-parm or the menu was updated.
44    fn update(&mut self) -> Result<()> {
45        let inner = self.inner_mut();
46        let name = inner.info.2.take();
47        let mut info = ParmInfo::from_parm_handle(inner.info.id(), inner.node, &inner.info.1)?;
48        info.2 = name;
49        inner.info = info;
50        Ok(())
51    }
52
53    /// If the parameter has choice menu.
54    #[inline]
55    fn is_menu(&self) -> bool {
56        !matches!(self.info().choice_list_type(), ChoiceListType::None)
57    }
58    /// If parameter is a menu type, return a vec of menu items
59    fn menu_items(&self) -> Result<Option<Vec<ParmChoiceInfo>>> {
60        if !self.is_menu() {
61            return Ok(None);
62        }
63        let inner = self.inner();
64        debug_assert!(inner.info.1.is_valid());
65        if inner.info.choice_count() == 0 {
66            return Ok(Some(Vec::new()));
67        }
68        let parms = crate::ffi::get_parm_choice_list(
69            inner.node,
70            &inner.info.1,
71            inner.info.choice_index(),
72            inner.info.choice_count(),
73        );
74        let parms = parms.map(|v| {
75            use std::ops::Deref;
76
77            v.into_iter()
78                .map(|p| ParmChoiceInfo(p, inner.info.1.deref().clone()))
79                .collect::<Vec<ParmChoiceInfo>>()
80        })?;
81        Ok(Some(parms))
82    }
83
84    /// If the parameter is a multiparm, return its children parms.
85    /// NOTE: THis is not a recommended way to traverse parameters in general,
86    /// this is here for convenience only
87    fn multiparm_children(&self) -> Result<Option<Vec<Parameter>>> {
88        let inner = self.inner();
89        if inner.info.parm_type() != ParmType::Multiparmlist {
90            return Ok(None);
91        }
92        let node = inner.node.to_node(&inner.info.1)?;
93        let mut all_parameters = node.parameters()?;
94        all_parameters.retain(|parm| {
95            parm.info().is_child_of_multi_parm() && parm.info().parent_id() == inner.info.id()
96        });
97
98        Ok(Some(all_parameters))
99    }
100
101    fn insert_multiparm_instance(&self, position: i32) -> Result<()> {
102        let ParmInfoWrap { info, node } = self.inner();
103        crate::ffi::insert_multiparm_instance(&info.1, *node, info.id(), position)
104    }
105
106    fn remove_multiparm_instance(&self, position: i32) -> Result<()> {
107        let ParmInfoWrap { info, node } = self.inner();
108        crate::ffi::remove_multiparm_instance(&info.1, *node, info.id(), position)
109    }
110
111    /// Returns a parameter expression string
112    fn expression(&self, index: i32) -> Result<Option<String>> {
113        let inner = self.inner();
114        debug_assert!(inner.info.1.is_valid());
115        let name = self.c_name()?;
116        let expr_string = crate::ffi::get_parm_expression(inner.node, &inner.info.1, &name, index)?;
117        Ok(if expr_string.is_empty() {
118            None
119        } else {
120            Some(expr_string)
121        })
122    }
123
124    /// Checks if parameter has an expression
125    fn has_expression(&self, index: i32) -> Result<bool> {
126        let inner = self.inner();
127        debug_assert!(inner.info.1.is_valid());
128        let name = self.c_name()?;
129        crate::ffi::parm_has_expression(inner.node, &inner.info.1, &name, index)
130    }
131
132    /// Set parameter expression
133    fn set_expression(&self, value: &str, index: i32) -> Result<()> {
134        let inner = self.inner();
135        debug_assert!(inner.info.1.is_valid());
136        let value = CString::new(value)?;
137        crate::ffi::set_parm_expression(inner.node, &inner.info.1, inner.info.id(), &value, index)
138    }
139
140    /// Remove parameter expression
141    fn remove_expression(&self, index: i32) -> Result<()> {
142        let inner = self.inner();
143        debug_assert!(inner.info.1.is_valid());
144        crate::ffi::remove_parm_expression(inner.node, &inner.info.1, inner.info.id(), index)
145    }
146
147    /// Revert parameter at index to its default value. If `index` is None - reset all instances.
148    fn revert_to_default(&self, index: Option<i32>) -> Result<()> {
149        let inner = self.inner();
150        crate::ffi::revert_parameter_to_default(inner.node, &inner.info.1, &self.c_name()?, index)
151    }
152
153    /// Set keyframes on the parameter
154    fn set_anim_curve(&self, index: i32, keys: &[KeyFrame]) -> Result<()> {
155        let inner = self.inner();
156        debug_assert!(inner.info.1.is_valid());
157        // SAFETY: Both structures have the same memory layout.
158        let keys =
159            unsafe { std::mem::transmute::<&[KeyFrame], &[crate::ffi::raw::HAPI_Keyframe]>(keys) };
160        crate::ffi::set_parm_anim_curve(&inner.info.1, inner.node, inner.info.id(), index, keys)
161    }
162
163    fn has_tag(&self, tag: &str) -> Result<bool> {
164        let inner = self.inner();
165        let tag = CString::new(tag)?;
166        crate::ffi::parm_has_tag(&inner.info.1, inner.node, inner.info.id(), &tag)
167    }
168
169    /// Get parameter tag name by index. The number of tags is stored in `self.info().tag_count()`
170    fn get_tag_name(&self, tag_index: i32) -> Result<String> {
171        let inner = self.inner();
172        crate::ffi::get_parm_tag_name(&inner.info.1, inner.node, inner.info.id(), tag_index)
173    }
174
175    fn get_tag_value(&self, tag_name: &str) -> Result<String> {
176        let inner = self.inner();
177        let tag = CString::new(tag_name)?;
178        crate::ffi::get_parm_tag_value(&inner.info.1, inner.node, inner.info.id(), &tag)
179    }
180
181    #[doc(hidden)]
182    // If the parameter was obtained by name (node.parameter(..))
183    // we store the name in the info struct, otherwise, call API to get name
184    fn c_name(&self) -> Result<Cow<'_, CStr>> {
185        let inner = self.inner();
186        match inner.info.2.as_deref() {
187            None => inner.info.name_cstr().map(Cow::Owned),
188            Some(name) => Ok(Cow::Borrowed(name)),
189        }
190    }
191    #[doc(hidden)]
192    fn inner(&self) -> &ParmInfoWrap;
193
194    #[doc(hidden)]
195    fn inner_mut(&mut self) -> &mut ParmInfoWrap;
196}
197
198#[derive(Debug)]
199#[doc(hidden)]
200pub struct ParmInfoWrap {
201    pub(crate) info: ParmInfo,
202    pub(crate) node: NodeHandle,
203}
204
205#[derive(Debug)]
206#[doc(hidden)]
207pub struct BaseParameter(pub(crate) ParmInfoWrap);
208
209/// Represents float parameters, including `Color` type.
210#[derive(Debug)]
211pub struct FloatParameter(pub(crate) ParmInfoWrap);
212
213/// Represents integer parameters, including `Button` type
214#[derive(Debug)]
215pub struct IntParameter(pub(crate) ParmInfoWrap);
216
217/// Represents string parameters of many different types.
218#[derive(Debug)]
219pub struct StringParameter(pub(crate) ParmInfoWrap);
220
221impl ParmBaseTrait for FloatParameter {
222    #[inline]
223    #[doc(hidden)]
224    fn inner(&self) -> &ParmInfoWrap {
225        &self.0
226    }
227
228    #[inline]
229    #[doc(hidden)]
230    fn inner_mut(&mut self) -> &mut ParmInfoWrap {
231        &mut self.0
232    }
233}
234
235impl ParmBaseTrait for IntParameter {
236    #[inline]
237    #[doc(hidden)]
238    fn inner(&self) -> &ParmInfoWrap {
239        &self.0
240    }
241
242    #[inline]
243    #[doc(hidden)]
244    fn inner_mut(&mut self) -> &mut ParmInfoWrap {
245        &mut self.0
246    }
247}
248
249impl ParmBaseTrait for StringParameter {
250    #[inline]
251    #[doc(hidden)]
252    fn inner(&self) -> &ParmInfoWrap {
253        &self.0
254    }
255
256    #[inline]
257    #[doc(hidden)]
258    fn inner_mut(&mut self) -> &mut ParmInfoWrap {
259        &mut self.0
260    }
261}
hapi_rs/parameter/base.rs

hapi_rs/parameter/
base.rs
