hapi_rs/parameter/
base.rs

1use crate::ffi::enums::ChoiceListType;
2use crate::ffi::{KeyFrame, ParmChoiceInfo, ParmInfo};
3use crate::node::{NodeHandle, ParmType};
4use crate::session::Session;
5use crate::Result;
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        crate::ffi::get_parm_expression(inner.node, &inner.info.1, &name, index)
117    }
118
119    /// Checks if parameter has an expression
120    fn has_expression(&self, index: i32) -> Result<bool> {
121        let inner = self.inner();
122        debug_assert!(inner.info.1.is_valid());
123        let name = self.c_name()?;
124        crate::ffi::parm_has_expression(inner.node, &inner.info.1, &name, index)
125    }
126
127    /// Set parameter expression
128    fn set_expression(&self, value: &str, index: i32) -> Result<()> {
129        let inner = self.inner();
130        debug_assert!(inner.info.1.is_valid());
131        let value = CString::new(value)?;
132        crate::ffi::set_parm_expression(inner.node, &inner.info.1, inner.info.id(), &value, index)
133    }
134
135    /// Remove parameter expression
136    fn remove_expression(&self, index: i32) -> Result<()> {
137        let inner = self.inner();
138        debug_assert!(inner.info.1.is_valid());
139        crate::ffi::remove_parm_expression(inner.node, &inner.info.1, inner.info.id(), index)
140    }
141
142    /// Revert parameter at index to its default value. If `index` is None - reset all instances.
143    fn revert_to_default(&self, index: Option<i32>) -> Result<()> {
144        let inner = self.inner();
145        crate::ffi::revert_parameter_to_default(inner.node, &inner.info.1, &self.c_name()?, index)
146    }
147
148    /// Set keyframes on the parameter
149    fn set_anim_curve(&self, index: i32, keys: &[KeyFrame]) -> Result<()> {
150        let inner = self.inner();
151        debug_assert!(inner.info.1.is_valid());
152        // SAFETY: Both structures have the same memory layout.
153        let keys =
154            unsafe { std::mem::transmute::<&[KeyFrame], &[crate::ffi::raw::HAPI_Keyframe]>(keys) };
155        crate::ffi::set_parm_anim_curve(&inner.info.1, inner.node, inner.info.id(), index, keys)
156    }
157
158    fn has_tag(&self, tag: &str) -> Result<bool> {
159        let inner = self.inner();
160        let tag = CString::new(tag)?;
161        crate::ffi::parm_has_tag(&inner.info.1, inner.node, inner.info.id(), &tag)
162    }
163
164    /// Get parameter tag name by index. The number of tags is stored in `self.info().tag_count()`
165    fn get_tag_name(&self, tag_index: i32) -> Result<String> {
166        let inner = self.inner();
167        crate::ffi::get_parm_tag_name(&inner.info.1, inner.node, inner.info.id(), tag_index)
168    }
169
170    fn get_tag_value(&self, tag_name: &str) -> Result<String> {
171        let inner = self.inner();
172        let tag = CString::new(tag_name)?;
173        crate::ffi::get_parm_tag_value(&inner.info.1, inner.node, inner.info.id(), &tag)
174    }
175
176    #[doc(hidden)]
177    // If the parameter was obtained by name (node.parameter(..))
178    // we store the name in the info struct, otherwise, call API to get name
179    fn c_name(&self) -> Result<Cow<CStr>> {
180        let inner = self.inner();
181        match inner.info.2.as_deref() {
182            None => inner.info.name_cstr().map(Cow::Owned),
183            Some(name) => Ok(Cow::Borrowed(name)),
184        }
185    }
186    #[doc(hidden)]
187    fn inner(&self) -> &ParmInfoWrap;
188
189    #[doc(hidden)]
190    fn inner_mut(&mut self) -> &mut ParmInfoWrap;
191}
192
193#[derive(Debug)]
194#[doc(hidden)]
195pub struct ParmInfoWrap {
196    pub(crate) info: ParmInfo,
197    pub(crate) node: NodeHandle,
198}
199
200#[derive(Debug)]
201#[doc(hidden)]
202pub struct BaseParameter(pub(crate) ParmInfoWrap);
203
204/// Represents float parameters, including `Color` type.
205#[derive(Debug)]
206pub struct FloatParameter(pub(crate) ParmInfoWrap);
207
208/// Represents integer parameters, including `Button` type
209#[derive(Debug)]
210pub struct IntParameter(pub(crate) ParmInfoWrap);
211
212/// Represents string parameters of many different types.
213#[derive(Debug)]
214pub struct StringParameter(pub(crate) ParmInfoWrap);
215
216impl ParmBaseTrait for FloatParameter {
217    #[inline]
218    #[doc(hidden)]
219    fn inner(&self) -> &ParmInfoWrap {
220        &self.0
221    }
222
223    #[inline]
224    #[doc(hidden)]
225    fn inner_mut(&mut self) -> &mut ParmInfoWrap {
226        &mut self.0
227    }
228}
229
230impl ParmBaseTrait for IntParameter {
231    #[inline]
232    #[doc(hidden)]
233    fn inner(&self) -> &ParmInfoWrap {
234        &self.0
235    }
236
237    #[inline]
238    #[doc(hidden)]
239    fn inner_mut(&mut self) -> &mut ParmInfoWrap {
240        &mut self.0
241    }
242}
243
244impl ParmBaseTrait for StringParameter {
245    #[inline]
246    #[doc(hidden)]
247    fn inner(&self) -> &ParmInfoWrap {
248        &self.0
249    }
250
251    #[inline]
252    #[doc(hidden)]
253    fn inner_mut(&mut self) -> &mut ParmInfoWrap {
254        &mut self.0
255    }
256}
hapi_rs/parameter/base.rs

hapi_rs/parameter/
base.rs
