device 0.0.4

A generative engine
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use {
  super::*,
  clap::{
    ArgAction,
    builder::styling::{AnsiColor, Effects, Styles},
  },
};

const AUDIO: &str = "audio";

#[derive(Clone, Default, Parser)]
#[command(
  version,
  styles = Styles::styled()
    .error(AnsiColor::Red.on_default() | Effects::BOLD)
    .header(AnsiColor::Yellow.on_default() | Effects::BOLD)
    .invalid(AnsiColor::Red.on_default())
    .literal(AnsiColor::Blue.on_default())
    .placeholder(AnsiColor::Cyan.on_default())
    .usage(AnsiColor::Yellow.on_default() | Effects::BOLD)
    .valid(AnsiColor::Green.on_default())
)]
pub(crate) struct Options {
  #[arg(allow_hyphen_values = true, long)]
  pub(crate) db: Option<f32>,
  #[arg(long, action = ArgAction::SetTrue)]
  pub(crate) fit: Option<bool>,
  #[arg(long)]
  pub(crate) fps: Option<Fps>,
  #[arg(long)]
  pub(crate) height: Option<NonZeroU32>,
  #[arg(long)]
  pub(crate) image_format: Option<ImageFormat>,
  #[arg(group = AUDIO, long)]
  pub(crate) input: bool,
  #[arg(long)]
  pub(crate) interpolate: Option<bool>,
  #[arg(long)]
  pub(crate) mute: bool,
  #[arg(long)]
  pub(crate) preset: Option<Vec<Preset>>,
  #[arg(long)]
  pub(crate) program: Option<Program>,
  #[arg(long)]
  pub(crate) resolution: Option<NonZeroU32>,
  #[arg(long)]
  pub(crate) scene: Option<Scene>,
  #[arg(group = AUDIO, long)]
  pub(crate) score: Option<Score>,
  #[arg(long)]
  pub(crate) seed: Option<u64>,
  #[arg(group = AUDIO, long)]
  pub(crate) song: Option<String>,
  #[arg(group = AUDIO, long)]
  pub(crate) track: Option<Utf8PathBuf>,
  #[arg(long)]
  pub(crate) verbose: bool,
  #[arg(allow_hyphen_values = true, long)]
  pub(crate) vw: Option<f32>,
  #[arg(allow_hyphen_values = true, long)]
  pub(crate) vx: Option<f32>,
  #[arg(allow_hyphen_values = true, long)]
  pub(crate) vy: Option<f32>,
  #[arg(allow_hyphen_values = true, long)]
  pub(crate) vz: Option<f32>,
  #[arg(long)]
  pub(crate) width: Option<NonZeroU32>,
}

impl Options {
  pub(crate) fn add_source(&self, config: &Config, tap: &mut Tap) -> Result {
    if let Some(song) = &self.song {
      let wave = tap.load_wave(&config.find_song(song)?)?;
      tap.sequence_wave(&wave, 0.0, 0.0);
    } else if let Some(score) = self.score {
      score.sequence(tap);
    } else if let Some(track) = &self.track {
      let wave = tap.load_wave(track)?;
      tap.sequence_wave(&wave, 0.0, 0.0);
    } else if let Some(program) = self.program {
      program.add_source(config, tap)?;
    }

    Ok(())
  }

  pub(crate) fn image_format(&self) -> Option<ImageFormat> {
    self
      .image_format
      .or_else(|| self.scene.and_then(Scene::image_format))
      .or_else(|| {
        self
          .program
          .and_then(|program| program.scene().image_format())
      })
  }

  pub(crate) fn size(&self, size: Size) -> (Size, NonZeroU32) {
    let size = Size::new(self.width.unwrap_or(size.x), self.height.unwrap_or(size.y));
    let resolution = self.resolution.unwrap_or(size.x.max(size.y));
    (size, resolution)
  }

  pub(crate) fn state(&self) -> State {
    let mut state = if let Some(scene) = self.scene {
      scene.state(self.seed)
    } else if let Some(program) = self.program {
      let mut state = program.scene().state(self.seed);
      if let Some(db) = program.db() {
        state.db = db;
      }
      state
    } else {
      default()
    };

    if let Some(presets) = &self.preset {
      for preset in presets {
        state.filters.push(preset.filter());
      }
    }

    state.db = self.db.unwrap_or(state.db);
    state.fit = self.fit.unwrap_or(state.fit);
    state.interpolate = self.interpolate.unwrap_or(state.interpolate);
    state.velocity = Vec4f::new(
      self.vx.unwrap_or(state.velocity.x),
      self.vy.unwrap_or(state.velocity.y),
      self.vz.unwrap_or(state.velocity.z),
      self.vw.unwrap_or(state.velocity.w),
    );

    state
  }

  pub(crate) fn stdio(&self) -> Stdio {
    if self.verbose {
      Stdio::inherit()
    } else {
      Stdio::piped()
    }
  }
}