orphist 0.3.0

a command-line interface for orphism
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

use orphism::{Error, Runtime};

#[derive(Debug, Clone, clap::Parser)]
#[remain::sorted]
pub struct Load {
  #[arg(long, value_name = "FILENAME")]
  match_filename: Option<String>,
  #[arg(long)]
  moc3: bool,
  #[arg(long, value_name = "GLOB", default_value = "./assets/**/*.model3.json")]
  pattern: String,
}

impl Load {
  pub fn execute(self) -> anyhow::Result<()> {
    let Self {
      match_filename: only_filename,
      moc3,
      pattern,
    } = self;

    let mut models = Vec::new();

    log::info!("looking for files matching {pattern:?}");

    for model in glob::glob(&pattern)? {
      let model = model?;

      if let (Some(file_name), Some(target)) = (model.file_name(), only_filename.as_ref()) {
        if !file_name.to_string_lossy().eq(target) {
          log::debug!("skipping {file_name:?} because it does not match {target:?}");
          continue;
        }
      }

      log::debug!("found {model:?}");

      if let Some(root) = model.as_path().parent() {
        log::debug!("attempting to load directory {root:?}");
        let runtime = match Runtime::new_from_runtime_path(root.to_owned()) {
          Ok(runtime) => {
            log::info!("loaded model from directory {root:?}");
            runtime
          }
          Err(Error::RuntimePathContainsMultipleModels(_)) => {
            log::debug!("failed because directory contains multiple models, attempting to load single model");
            match Runtime::new_from_model_path(model.clone()) {
              Ok(runtime) => {
                log::info!("loaded model from file: {model:?}");
                runtime
              }
              Err(error) => Err(error)?,
            }
          }
          Err(error) => Err(error)?,
        };
        let model = runtime.load_model()?;
        models.push(model);
      }
    }

    log::info!("successfully loaded {} models", models.len());

    if moc3 {
      log::info!("attempting to parse .moc3 data from all loaded models");

      for model in models {
        let model = orphism::moc3::Model::read(model.data)?;

        println!("{model:#?}");
      }
    }

    Ok(())
  }
}