motionloom 0.1.0

MotionLoom DSL parser and renderer for video effects, scene graphs, motion graphics, and world graphs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

// =========================================
// =========================================
// crates/motionloom/src/scene/error.rs

use std::path::PathBuf;

use thiserror::Error;

#[derive(Debug, Error)]
pub enum MotionLoomSceneRenderError {
    #[error(
        "MotionLoom scene graph requires at least one node such as <Background>, <Scene>, <Text>, <Image>, <Svg>, <Rect>, <Circle>, <Line>, <Polyline>, <Path>, <FaceJaw>, <Group>, <Mask>, or <Character>."
    )]
    EmptyScene,
    #[error("failed to read system time: {source}")]
    ReadTime { source: std::time::SystemTimeError },
    #[error("failed to create output directory ({path}): {source}")]
    CreateOutputDir {
        path: PathBuf,
        source: std::io::Error,
    },
    #[error("failed to start ffmpeg: {source}")]
    StartFfmpeg { source: std::io::Error },
    #[error("ffmpeg stdin was not available")]
    MissingFfmpegStdin,
    #[error("failed to write raw frame to ffmpeg: {source}. ffmpeg stderr: {stderr}")]
    WriteFrame {
        source: std::io::Error,
        stderr: String,
    },
    #[error("failed to wait for ffmpeg: {source}")]
    WaitFfmpeg { source: std::io::Error },
    #[error("ffmpeg failed: {stderr}")]
    FfmpegFailed { stderr: String },
    #[error("failed to save PNG frame ({path}): {source}")]
    SavePngFrame {
        path: PathBuf,
        source: image::ImageError,
    },
    #[error("invalid color '{value}'")]
    InvalidColor { value: String },
    #[error("invalid scene paint '{value}': {message}")]
    InvalidPaint { value: String, message: String },
    #[error("invalid scene expression '{expr}': {message}")]
    InvalidExpression { expr: String, message: String },
    #[error("invalid scene path data '{value}': {message}")]
    InvalidPathData { value: String, message: String },
    #[error("invalid scene deform grid '{value}': {message}")]
    InvalidDeformGrid { value: String, message: String },
    #[error("failed to open image asset ({path}): {source}")]
    OpenImage {
        path: PathBuf,
        source: image::ImageError,
    },
    #[error("failed to fetch media asset ({url}): {message}")]
    FetchAsset { url: String, message: String },
    #[error("failed to decode image asset ({source_ref}): {source}")]
    DecodeImage {
        source_ref: String,
        source: image::ImageError,
    },
    #[error("failed to read SVG asset ({path}): {source}")]
    ReadSvg {
        path: PathBuf,
        source: std::io::Error,
    },
    #[error("failed to parse SVG asset ({source_ref}): {source}")]
    ParseSvg {
        source_ref: String,
        source: resvg::usvg::Error,
    },
    #[error("failed to render SVG asset ({source_ref}): invalid SVG size")]
    RenderSvg { source_ref: String },
    #[error("invalid image data URI ({source_ref}): {message}")]
    InvalidImageDataUri { source_ref: String, message: String },
    #[error("invalid SVG data URI ({source_ref}): {message}")]
    InvalidSvgDataUri { source_ref: String, message: String },
    #[error("GPU scene render failed: {message}")]
    GpuRender { message: String },
    #[error("world source render failed: {message}")]
    WorldSource { message: String },
    #[error("video export is not available on this platform: {message}")]
    VideoExportNotAvailable { message: String },
    #[error("scene render cancelled")]
    Cancelled,
}

impl From<crate::export::EncodeError> for MotionLoomSceneRenderError {
    fn from(err: crate::export::EncodeError) -> Self {
        use crate::export::EncodeError;
        match err {
            EncodeError::CreateOutputDir { path, source } => Self::CreateOutputDir { path, source },
            EncodeError::StartEncoder(message) => Self::StartFfmpeg {
                source: std::io::Error::other(message),
            },
            EncodeError::MissingEncoderInput => Self::MissingFfmpegStdin,
            EncodeError::WriteFrame(source) => Self::WriteFrame {
                source,
                stderr: String::new(),
            },
            EncodeError::EncoderFailed(stderr) => Self::FfmpegFailed { stderr },
            EncodeError::NotImplemented(message) => Self::VideoExportNotAvailable { message },
            EncodeError::NotStarted => Self::GpuRender {
                message: "encoder was not started".to_string(),
            },
        }
    }
}

pub type SceneRenderError = MotionLoomSceneRenderError;