mod scene;
use alloc::collections::TryReserveError;
use alloc::rc::Rc;
use alloc::vec::Vec;
use core::{error, fmt, ptr};
pub use scene::{ScreenplayScene, ScreenplaySceneFlags};
use crate::events::EventListError;
use crate::formats::binary::{BinaryFile, BinaryFileError};
use crate::lights::LightProgramError;
use crate::rth_plan::{RthPlan, RthPlanError};
use crate::trajectory::TrajectoryError;
use crate::yaw_control::YawControlError;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ScreenplayError {
MissingTrajectory,
InvalidDuration,
File(BinaryFileError),
Trajectory(TrajectoryError),
LightProgram(LightProgramError),
YawControl(YawControlError),
EventList(EventListError),
RthPlan(RthPlanError),
OutOfMemory,
}
impl fmt::Display for ScreenplayError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::MissingTrajectory => f.write_str("the show file has no trajectory"),
Self::InvalidDuration => f.write_str("the duration of the scene is out of range"),
Self::File(_) => f.write_str("the show file could not be read"),
Self::Trajectory(_) => f.write_str("the trajectory could not be read"),
Self::LightProgram(_) => f.write_str("the light program could not be read"),
Self::YawControl(_) => f.write_str("the yaw control could not be read"),
Self::EventList(_) => f.write_str("the events could not be read"),
Self::RthPlan(_) => f.write_str("the RTH plan could not be read"),
Self::OutOfMemory => f.write_str("out of memory"),
}
}
}
impl error::Error for ScreenplayError {
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
match self {
Self::File(err) => Some(err),
Self::Trajectory(err) => Some(err),
Self::LightProgram(err) => Some(err),
Self::YawControl(err) => Some(err),
Self::EventList(err) => Some(err),
Self::RthPlan(err) => Some(err),
Self::MissingTrajectory | Self::InvalidDuration | Self::OutOfMemory => None,
}
}
}
impl From<BinaryFileError> for ScreenplayError {
fn from(err: BinaryFileError) -> Self {
Self::File(err)
}
}
impl From<TrajectoryError> for ScreenplayError {
fn from(err: TrajectoryError) -> Self {
Self::Trajectory(err)
}
}
impl From<LightProgramError> for ScreenplayError {
fn from(err: LightProgramError) -> Self {
Self::LightProgram(err)
}
}
impl From<YawControlError> for ScreenplayError {
fn from(err: YawControlError) -> Self {
Self::YawControl(err)
}
}
impl From<EventListError> for ScreenplayError {
fn from(err: EventListError) -> Self {
Self::EventList(err)
}
}
impl From<RthPlanError> for ScreenplayError {
fn from(err: RthPlanError) -> Self {
Self::RthPlan(err)
}
}
impl From<TryReserveError> for ScreenplayError {
fn from(_: TryReserveError) -> Self {
Self::OutOfMemory
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Screenplay<'a> {
scenes: Vec<ScreenplayScene<'a>>,
rth_plan: Option<Rc<RthPlan<'a>>>,
}
impl<'a> Screenplay<'a> {
#[must_use]
pub const fn new() -> Self {
Self {
scenes: Vec::new(),
rth_plan: None,
}
}
pub fn from_binary_file(file: &BinaryFile<'a>) -> Result<Self, ScreenplayError> {
let scene = ScreenplayScene::from_binary_file(file)?;
let rth_plan = RthPlan::from_binary_file(file)?;
let mut scenes = Vec::new();
scenes.try_reserve_exact(1)?;
scenes.push(scene);
Ok(Self {
scenes,
rth_plan: rth_plan.map(Rc::new),
})
}
#[must_use]
pub const fn capacity(&self) -> usize {
self.scenes.capacity()
}
#[must_use]
pub const fn len(&self) -> usize {
self.scenes.len()
}
#[must_use]
pub const fn is_empty(&self) -> bool {
self.scenes.is_empty()
}
#[must_use]
pub fn contains_scene(&self, scene: &ScreenplayScene<'_>) -> bool {
self.scenes.iter().any(|other| ptr::addr_eq(other, scene))
}
#[must_use]
pub fn scenes(&self) -> &[ScreenplayScene<'a>] {
&self.scenes
}
#[must_use]
pub fn scene(&self, index: usize) -> Option<&ScreenplayScene<'a>> {
self.scenes.get(index)
}
pub fn scene_mut(&mut self, index: usize) -> Option<&mut ScreenplayScene<'a>> {
self.scenes.get_mut(index)
}
#[must_use]
pub fn scene_at_time_msec(&self, time_msec: u32) -> Option<(usize, &ScreenplayScene<'a>)> {
self.scenes
.iter()
.enumerate()
.find(|(_, scene)| scene.contains_time_msec(time_msec))
}
#[must_use]
pub fn find_first_scene_with_tag(&self, tag: u8) -> Option<&ScreenplayScene<'a>> {
self.scenes.iter().find(|scene| scene.tag() == tag)
}
#[must_use]
pub fn time_msec_for_scene_tag_and_warped_time_in_scene(
&self,
tag: u8,
warped_time_sec: f32,
) -> Option<u32> {
if warped_time_sec.is_nan() {
return None;
}
let index = self.scenes.iter().position(|scene| scene.tag() == tag)?;
let scene = self.scenes.get(index)?;
let origin_msec = scene.origin_msec();
let time_msec = scene.time_axis().reverse_map(warped_time_sec);
if time_msec < origin_msec || time_msec == i32::MAX {
return None;
}
let elapsed_msec = i64::from(time_msec) - i64::from(origin_msec);
if !scene.is_infinite() && elapsed_msec > i64::from(scene.duration_msec()) {
return None;
}
let earlier = self.scenes.get(..index).unwrap_or_default();
let time_msec = u32::try_from(time_msec).ok()?;
if earlier
.iter()
.any(|other| other.contains_time_msec(time_msec))
{
return None;
}
Some(time_msec)
}
#[must_use]
#[expect(
clippy::cast_precision_loss,
reason = "times in seconds are floats, as in the C library"
)]
pub fn time_sec_for_scene_tag_and_warped_time_in_scene(
&self,
tag: u8,
warped_time_sec: f32,
) -> Option<f32> {
self.time_msec_for_scene_tag_and_warped_time_in_scene(tag, warped_time_sec)
.map(|time_msec| time_msec as f32 / 1000.0)
}
pub fn clear(&mut self) {
self.scenes.clear();
self.rth_plan = None;
}
pub fn append_new_scene(&mut self) -> Result<&mut ScreenplayScene<'a>, ScreenplayError> {
self.scenes.try_reserve(1)?;
self.scenes.push(ScreenplayScene::new());
self.scenes.last_mut().ok_or(ScreenplayError::OutOfMemory)
}
pub fn remove_last_scene(&mut self) -> Option<ScreenplayScene<'a>> {
self.scenes.pop()
}
#[must_use]
pub const fn rth_plan(&self) -> Option<&Rc<RthPlan<'a>>> {
self.rth_plan.as_ref()
}
pub fn set_rth_plan(&mut self, rth_plan: Option<Rc<RthPlan<'a>>>) {
self.rth_plan = rth_plan;
}
}