use crate::{OwnedArgument, OwnedData, RecordError, Scene};
use nsi_ffi_wrap::Arg;
use nsi_trait::{Action, Nsi};
use parking_lot::{Mutex, MutexGuard};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum RenderState {
#[default]
Idle,
Running,
Suspended,
}
#[derive(Debug, Default)]
pub struct Recorder {
scene: Mutex<Scene>,
state: Mutex<RenderState>,
}
impl Recorder {
pub fn new() -> Self {
Self::default()
}
pub fn scene(&self) -> MutexGuard<'_, Scene> {
self.scene.lock()
}
pub fn into_scene(self) -> Scene {
self.scene.into_inner()
}
pub fn render_state(&self) -> RenderState {
*self.state.lock()
}
fn own(args: &[Arg<'_, 'static>]) -> Vec<OwnedArgument> {
args.iter().map(OwnedArgument::from_param).collect()
}
}
impl Nsi for Recorder {
type Arg<'call> = Arg<'call, 'static>;
type Error = RecordError;
fn create(
&self,
handle: &str,
node_type: &str,
_args: Option<&[Self::Arg<'_>]>,
) -> Result<(), Self::Error> {
self.scene().create(handle, node_type)
}
fn delete(
&self,
handle: &str,
args: Option<&[Self::Arg<'_>]>,
) -> Result<(), Self::Error> {
let recursive = args
.unwrap_or_default()
.iter()
.map(OwnedArgument::from_param)
.find(|arg| arg.name == "recursive")
.is_some_and(|arg| match &arg.data {
OwnedData::I32(values) => {
values.first().is_some_and(|v| *v != 0)
}
_ => false,
});
if recursive {
self.scene().delete_recursive(handle)
} else {
self.scene().delete(handle)
}
}
fn set_attribute(
&self,
handle: &str,
args: &[Self::Arg<'_>],
) -> Result<(), Self::Error> {
let owned = Self::own(args);
self.scene().set_attribute(handle, owned)
}
fn set_attribute_at_time(
&self,
handle: &str,
time: f64,
args: &[Self::Arg<'_>],
) -> Result<(), Self::Error> {
let owned = Self::own(args);
self.scene().set_attribute_at_time(handle, time, owned)
}
fn delete_attribute(
&self,
handle: &str,
name: &str,
) -> Result<(), Self::Error> {
self.scene().delete_attribute(handle, name);
Ok(())
}
fn connect(
&self,
from: &str,
from_attribute: Option<&str>,
to: &str,
to_attribute: &str,
args: Option<&[Self::Arg<'_>]>,
) -> Result<(), Self::Error> {
let args = args.map(Self::own).unwrap_or_default();
self.scene().connect_with_arguments(
from,
from_attribute,
to,
to_attribute,
args,
)
}
fn disconnect(
&self,
from: &str,
from_attribute: Option<&str>,
to: &str,
to_attribute: &str,
) -> Result<(), Self::Error> {
self.scene()
.disconnect(from, from_attribute, to, to_attribute)
}
fn evaluate(&self, args: &[Self::Arg<'_>]) -> Result<(), Self::Error> {
self.scene().evaluate(Self::own(args));
Ok(())
}
fn render_control(
&self,
action: Action,
_args: Option<&[Self::Arg<'_>]>,
) -> Result<(), Self::Error> {
let mut state = self.state.lock();
*state = match (action, *state) {
(Action::Start, _) => RenderState::Running,
(Action::Suspend, RenderState::Running) => RenderState::Suspended,
(Action::Resume, RenderState::Suspended) => RenderState::Running,
(Action::Stop, _) => RenderState::Idle,
(_, current) => current,
};
Ok(())
}
}
#[cfg(test)]
mod tests;