Add 3D assets for each KCL example (#7995)

Each KCL example will generate a GLTF file and store it in the repo. This will be used for adding 3D interactive models to the KCL docs pages.

Once this has merged, follow-up PRs will:

- Include the models in the handlebars template for generating each KCL function's markdown doc
- In the `website` repo, copy the models from the `documentation` submodule to a public static assets dir.

Author: adamchalmers

.github/workflows/generate-website-docs.yml

@@ -40,9 +40,11 @@ jobs:
           # cleanup old
           rm -rf documentation/content/pages/docs/kcl-std
           rm -rf documentation/content/pages/docs/kcl-lang
+          rm -rf documentation/content/kcl-test-outputs
           # move new
           mv -f docs/kcl-std documentation/content/pages/docs
           mv -f docs/kcl-lang documentation/content/pages/docs
+          mv -f rust/kcl-lib/tests/outputs documentation/content/kcl-test-outputs
           # We don't need the README
           rm documentation/content/pages/docs/kcl-std/README.md
       - name: move kcl-samples

docs/kcl-std/functions/std-transform-mirror2d.md

@@ -1,4 +1,4 @@
-cnr := "cargo nextest run"
+cnr := "cargo nextest run --no-fail-fast"
 cita := "cargo insta test --accept"
 kcl_lib_flags := "-p kcl-lib --features artifact-graph"
 

rust/justfile

@@ -1344,7 +1344,7 @@ mod test {
             if i != number {
                 continue;
             }
-            let result = match crate::test_server::execute_and_snapshot(&eg.0, None).await {
+            let result = match crate::test_server::execute_and_snapshot_3d(&eg.0, None).await {
                 Err(crate::errors::ExecError::Kcl(e)) => {
                     panic!("Error testing example {}{i}: {}", d.name, e.error.message());
                 }
@@ -1359,9 +1359,18 @@ mod test {
                     "tests/outputs/serial_test_example_fn_{}{i}.png",
                     qualname.replace("::", "-")
                 ),
-                &result,
+                &result.image,
                 0.99,
             );
+            for gltf_file in result.gltf {
+                let path = format!(
+                    "tests/outputs/models/serial_test_example_fn_{}{i}_{}",
+                    qualname.replace("::", "-"),
+                    gltf_file.name,
+                );
+                let mut f = std::fs::File::create(path).expect("could not create file");
+                std::io::Write::write_all(&mut f, &gltf_file.contents).expect("could not write to file");
+            }
             return;
         }
 

rust/kcl-lib/src/docs/kcl_doc.rs

@@ -2,6 +2,8 @@
 
 use std::path::PathBuf;
 
+use kittycad_modeling_cmds::websocket::RawFile;
+
 use crate::{
     ConnectionError, ExecError, KclError, KclErrorWithOutputs, Program,
     engine::new_zoo_client,
@@ -29,6 +31,35 @@ pub async fn execute_and_snapshot(code: &str, current_file: Option<PathBuf>) ->
     res
 }
 
+pub struct Snapshot3d {
+    /// Bytes of the snapshot.
+    pub image: image::DynamicImage,
+    /// Various GLTF files for the resulting export.
+    pub gltf: Vec<RawFile>,
+}
+
+/// Executes a kcl program and takes a snapshot of the result.
+pub async fn execute_and_snapshot_3d(code: &str, current_file: Option<PathBuf>) -> Result<Snapshot3d, ExecError> {
+    let ctx = new_context(true, current_file).await?;
+    let program = Program::parse_no_errs(code).map_err(KclErrorWithOutputs::no_outputs)?;
+    let image = do_execute_and_snapshot(&ctx, program)
+        .await
+        .map(|(_, _, snap)| snap)
+        .map_err(|err| err.error)?;
+    let gltf_res = ctx
+        .export(kittycad_modeling_cmds::format::OutputFormat3d::Gltf(Default::default()))
+        .await;
+    let gltf = match gltf_res {
+        Err(err) if err.message() == "Nothing to export" => Vec::new(),
+        Err(err) => {
+            eprintln!("Error exporting: {}", err.message());
+            Vec::new()
+        }
+        Ok(x) => x,
+    };
+    ctx.close().await;
+    Ok(Snapshot3d { image, gltf })
+}
 /// Executes a kcl program and takes a snapshot of the result.
 /// This returns the bytes of the snapshot.
 #[cfg(test)]