kittycad-modeling-cmds 0.2.199

use bon::Builder;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

use crate::shared::{FileExportFormat, FileExportFormat2d, FileImportFormat};

/// AutoCAD drawing interchange format.
pub mod dxf;
/// Autodesk Filmbox (FBX) format.
pub mod fbx;
/// glTF 2.0.
/// We refer to this as glTF since that is how our customers refer to it, although by default
/// it will be in binary format and thus technically (glb).
/// If you prefer ASCII output, you can set that option for the export.
pub mod gltf;
/// Wavefront OBJ format.
pub mod obj;
/// The PLY Polygon File Format.
pub mod ply;
/// ISO 10303-21 (STEP) format.
pub mod step;
/// **ST**ereo**L**ithography format.
pub mod stl;

/// Output 2D format specifier.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(tag = "type", rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum OutputFormat2d {
    /// AutoCAD drawing interchange format.
    Dxf(dxf::export::Options),
}

/// Alias for backward compatibility.
#[deprecated(since = "0.2.96", note = "use `OutputFormat3d` instead")]
pub type OutputFormat = OutputFormat3d;

/// Output 3D format specifier.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(tag = "type", rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum OutputFormat3d {
    /// Autodesk Filmbox (FBX) format.
    Fbx(fbx::export::Options),
    /// glTF 2.0.
    /// We refer to this as glTF since that is how our customers refer to it, although by default
    /// it will be in binary format and thus technically (glb).
    /// If you prefer ASCII output, you can set that option for the export.
    Gltf(gltf::export::Options),
    /// Wavefront OBJ format.
    Obj(obj::export::Options),
    /// The PLY Polygon File Format.
    Ply(ply::export::Options),
    /// ISO 10303-21 (STEP) format.
    Step(step::export::Options),
    /// **ST**ereo**L**ithography format.
    Stl(stl::export::Options),
}

/// Alias for backward compatibility.
#[deprecated(since = "0.2.96", note = "use `InputFormat3d` instead")]
pub type InputFormat = InputFormat3d;

/// Input format specifier.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(tag = "type", rename_all = "snake_case")]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass,
    pyo3_stub_gen::derive::gen_stub_pyclass_complex_enum
)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum InputFormat3d {
    /// ACIS part format.
    Acis(acis::import::Options),
    /// CATIA part format.
    Catia(catia::import::Options),
    /// PTC Creo part format.
    Creo(creo::import::Options),
    /// Autodesk Filmbox (FBX) format.
    Fbx(fbx::import::Options),
    /// Binary glTF 2.0.
    /// We refer to this as glTF since that is how our customers refer to it,
    /// but this can also import binary glTF (glb).
    Gltf(gltf::import::Options),
    /// Autodesk Inventor part format.
    Inventor(inventor::import::Options),
    /// Siemens NX part format.
    Nx(nx::import::Options),
    /// Wavefront OBJ format.
    Obj(obj::import::Options),
    /// Parasolid part format.
    Parasolid(parasolid::import::Options),
    /// The PLY Polygon File Format.
    Ply(ply::import::Options),
    /// SolidWorks part (SLDPRT) format.
    Sldprt(sldprt::import::Options),
    /// ISO 10303-21 (STEP) format.
    Step(step::import::Options),
    /// **ST**ereo**L**ithography format.
    Stl(stl::import::Options),
}

impl InputFormat3d {
    /// Get the name of this format.
    pub fn name(&self) -> &'static str {
        match self {
            InputFormat3d::Acis(_) => "acis",
            InputFormat3d::Catia(_) => "catia",
            InputFormat3d::Creo(_) => "creo",
            InputFormat3d::Fbx(_) => "fbx",
            InputFormat3d::Gltf(_) => "gltf",
            InputFormat3d::Inventor(_) => "inventor",
            InputFormat3d::Nx(_) => "nx",
            InputFormat3d::Parasolid(_) => "parasolid",
            InputFormat3d::Obj(_) => "obj",
            InputFormat3d::Ply(_) => "ply",
            InputFormat3d::Sldprt(_) => "sldprt",
            InputFormat3d::Step(_) => "step",
            InputFormat3d::Stl(_) => "stl",
        }
    }
}

/// Data item selection.
#[derive(Clone, Debug, Default, Eq, Hash, PartialEq, JsonSchema, Deserialize, Serialize)]
#[serde(rename_all = "snake_case", tag = "type")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum Selection {
    /// Visit the default scene.
    #[default]
    DefaultScene,

    /// Visit the indexed scene.
    SceneByIndex {
        /// The index.
        index: usize,
    },

    /// Visit the first scene with the given name.
    SceneByName {
        /// The name.
        name: String,
    },

    /// Visit the indexed mesh.
    MeshByIndex {
        /// The index.
        index: usize,
    },

    /// Visit the first mesh with the given name.
    MeshByName {
        /// The name.
        name: String,
    },
}

/// Represents an in-memory file with an associated potentially foreign file path.
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, Builder)]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct VirtualFile {
    /// Original file path.
    pub path: std::path::PathBuf,
    /// File payload.
    pub data: Vec<u8>,
}

impl VirtualFile {
    /// Returns true if the file name has the given extension.
    pub fn has_extension(&self, required_extension: &str) -> bool {
        self.path
            .extension()
            .and_then(std::ffi::OsStr::to_str)
            .map(|extension| extension.eq_ignore_ascii_case(required_extension))
            .unwrap_or(false)
    }

    fn read_fs_impl(path: std::path::PathBuf) -> std::io::Result<Self> {
        let data = std::fs::read(&path)?;
        Ok(Self { path, data })
    }

    /// Read from file system.
    pub fn read_fs<P>(path: P) -> std::io::Result<Self>
    where
        P: Into<std::path::PathBuf>,
    {
        Self::read_fs_impl(path.into())
    }
}

impl From<OutputFormat3d> for FileExportFormat {
    fn from(output_format: OutputFormat3d) -> Self {
        match output_format {
            OutputFormat3d::Fbx(_) => Self::Fbx,
            OutputFormat3d::Gltf(_) => Self::Gltf,
            OutputFormat3d::Obj(_) => Self::Obj,
            OutputFormat3d::Ply(_) => Self::Ply,
            OutputFormat3d::Step(_) => Self::Step,
            OutputFormat3d::Stl(_) => Self::Stl,
        }
    }
}

impl From<OutputFormat2d> for FileExportFormat2d {
    fn from(output_format: OutputFormat2d) -> Self {
        match output_format {
            OutputFormat2d::Dxf(_) => Self::Dxf,
        }
    }
}

impl From<FileExportFormat2d> for OutputFormat2d {
    fn from(export_format: FileExportFormat2d) -> Self {
        match export_format {
            FileExportFormat2d::Dxf => OutputFormat2d::Dxf(Default::default()),
        }
    }
}

impl From<FileExportFormat> for OutputFormat3d {
    fn from(export_format: FileExportFormat) -> Self {
        match export_format {
            FileExportFormat::Fbx => OutputFormat3d::Fbx(Default::default()),
            FileExportFormat::Glb => OutputFormat3d::Gltf(gltf::export::Options {
                storage: gltf::export::Storage::Binary,
                ..Default::default()
            }),
            FileExportFormat::Gltf => OutputFormat3d::Gltf(gltf::export::Options {
                storage: gltf::export::Storage::Embedded,
                presentation: gltf::export::Presentation::Pretty,
            }),
            FileExportFormat::Obj => OutputFormat3d::Obj(Default::default()),
            FileExportFormat::Ply => OutputFormat3d::Ply(Default::default()),
            FileExportFormat::Step => OutputFormat3d::Step(Default::default()),
            FileExportFormat::Stl => OutputFormat3d::Stl(stl::export::Options {
                storage: stl::export::Storage::Ascii,
                ..Default::default()
            }),
        }
    }
}

impl From<InputFormat3d> for FileImportFormat {
    fn from(input_format: InputFormat3d) -> Self {
        match input_format {
            InputFormat3d::Acis(_) => Self::Acis,
            InputFormat3d::Catia(_) => Self::Catia,
            InputFormat3d::Creo(_) => Self::Creo,
            InputFormat3d::Fbx(_) => Self::Fbx,
            InputFormat3d::Gltf(_) => Self::Gltf,
            InputFormat3d::Inventor(_) => Self::Inventor,
            InputFormat3d::Nx(_) => Self::Nx,
            InputFormat3d::Obj(_) => Self::Obj,
            InputFormat3d::Parasolid(_) => Self::Parasolid,
            InputFormat3d::Ply(_) => Self::Ply,
            InputFormat3d::Sldprt(_) => Self::Sldprt,
            InputFormat3d::Step(_) => Self::Step,
            InputFormat3d::Stl(_) => Self::Stl,
        }
    }
}

impl From<FileImportFormat> for InputFormat3d {
    fn from(import_format: FileImportFormat) -> Self {
        match import_format {
            FileImportFormat::Acis => InputFormat3d::Acis(Default::default()),
            FileImportFormat::Catia => InputFormat3d::Catia(Default::default()),
            FileImportFormat::Creo => InputFormat3d::Creo(Default::default()),
            FileImportFormat::Fbx => InputFormat3d::Fbx(Default::default()),
            FileImportFormat::Gltf => InputFormat3d::Gltf(Default::default()),
            FileImportFormat::Inventor => InputFormat3d::Inventor(Default::default()),
            FileImportFormat::Nx => InputFormat3d::Nx(Default::default()),
            FileImportFormat::Obj => InputFormat3d::Obj(Default::default()),
            FileImportFormat::Parasolid => InputFormat3d::Parasolid(Default::default()),
            FileImportFormat::Ply => InputFormat3d::Ply(Default::default()),
            FileImportFormat::Sldprt => InputFormat3d::Sldprt(Default::default()),
            FileImportFormat::Step => InputFormat3d::Step(Default::default()),
            FileImportFormat::Stl => InputFormat3d::Stl(Default::default()),
        }
    }
}

/// Options for a 3D export.
pub struct OutputFormat3dOptions {
    src_unit: crate::units::UnitLength,
}

impl OutputFormat3dOptions {
    /// Create the options, setting all optional fields to their defaults.
    pub fn new(src_unit: crate::units::UnitLength) -> Self {
        Self { src_unit }
    }
}

impl OutputFormat3d {
    /// Create the output format, setting the options as given.
    pub fn new(format: &FileExportFormat, options: OutputFormat3dOptions) -> Self {
        let OutputFormat3dOptions { src_unit } = options;
        // Zoo co-ordinate system.
        //
        // * Forward: -Y
        // * Up: +Z
        // * Handedness: Right
        let coords = crate::coord::System {
            forward: crate::coord::AxisDirectionPair {
                axis: crate::coord::Axis::Y,
                direction: crate::coord::Direction::Negative,
            },
            up: crate::coord::AxisDirectionPair {
                axis: crate::coord::Axis::Z,
                direction: crate::coord::Direction::Positive,
            },
        };

        match format {
            FileExportFormat::Fbx => Self::Fbx(fbx::export::Options {
                storage: fbx::export::Storage::Binary,
                created: None,
            }),
            FileExportFormat::Glb => Self::Gltf(gltf::export::Options {
                storage: gltf::export::Storage::Binary,
                presentation: gltf::export::Presentation::Compact,
            }),
            FileExportFormat::Gltf => Self::Gltf(gltf::export::Options {
                storage: gltf::export::Storage::Embedded,
                presentation: gltf::export::Presentation::Pretty,
            }),
            FileExportFormat::Obj => Self::Obj(obj::export::Options {
                coords,
                units: src_unit,
            }),
            FileExportFormat::Ply => Self::Ply(ply::export::Options {
                storage: ply::export::Storage::Ascii,
                coords,
                selection: Selection::DefaultScene,
                units: src_unit,
            }),
            FileExportFormat::Step => Self::Step(step::export::Options {
                coords,
                created: None,
                units: src_unit,
                presentation: step::export::Presentation::Pretty,
            }),
            FileExportFormat::Stl => Self::Stl(stl::export::Options {
                storage: stl::export::Storage::Ascii,
                coords,
                units: src_unit,
                selection: Selection::DefaultScene,
            }),
        }
    }
}

macro_rules! proprietary_brep_formats {
    {
        $(
            (
                $mod_name:ident,
                $spec_name:literal,
                $format_description:literal,
                $coordinate_system:expr
            )
        )*
    } => {
        $(
            #[doc = $format_description]
            pub mod $mod_name {
                /// Import functionality
                pub mod import {
                    use bon::Builder;
                    use schemars::JsonSchema;
                    use serde::{Deserialize, Serialize};
                    use crate::coord;

                    #[doc = std::concat!("Options for importing ", $format_description, ".")]
                    #[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
                    #[serde(default, rename = $spec_name)]
                    #[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
                    #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
                    #[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
                    #[cfg_attr(
                        feature = "python",
                        pyo3_stub_gen::derive::gen_stub_pyclass,
                        pyo3::pyclass(name = $spec_name)
                    )]
                    pub struct Options {
                        /// Co-ordinate system of input data.
                        #[builder(default = *$coordinate_system)]
                        pub coords: coord::System,

                        /// Splits all closed faces into two open faces.
                        ///
                        /// Defaults to `false` but is implicitly `true` when importing into the engine.
                        #[builder(default)]
                        pub split_closed_faces: bool,
                    }

                    #[cfg(feature = "python")]
                    #[pyo3_stub_gen::derive::gen_stub_pymethods]
                    #[pyo3::pymethods]
                    impl Options {
                        #[new]
                        /// Set the options to their defaults.
                        pub fn new() -> Self {
                            Default::default()
                        }
                    }

                    impl Default for Options {
                        fn default() -> Self {
                            Self {
                                coords: *$coordinate_system,
                                split_closed_faces: false,
                            }
                        }
                    }
                }
            }
        )*
    };
}

proprietary_brep_formats! {
    (acis, "AcisImportOptions", "ACIS part format", coord::KITTYCAD)
    (catia, "CatiaImportOptions", "CATIA part format", coord::KITTYCAD)
    (creo, "CreoImportOptions", "PTC Creo part format", coord::OPENGL)
    (inventor, "InventorImportOptions", "Autodesk Inventor part format", coord::KITTYCAD)
    (nx, "NxImportOptions", "Siemens NX part format", coord::KITTYCAD)
    (parasolid, "ParasolidImportOptions", "Parasolid part format", coord::KITTYCAD)
    (sldprt, "SldprtImportOptions", "SolidWorks part format", coord::OPENGL)
}