build: install scenes properly

build.rs

@@ -0,0 +1,39 @@
+use std::path::Path;
+
+fn copy_dir(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> std::io::Result<()> {
+    std::fs::create_dir_all(&dst)?;
+    for entry in std::fs::read_dir(src)? {
+        let entry = entry?;
+        if entry.file_type()?.is_dir() {
+            copy_dir(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        } else {
+            std::fs::copy(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        }
+    }
+    Ok(())
+}
+
+fn main() {
+    let use_local_scenes = std::env::var("LISPERS_USE_LOCAL_SCENES").unwrap_or_default() == "1";
+    let no_copy = std::env::var("LISPERS_DONT_COPY_SCENES").unwrap_or_default() == "1";
+
+    let out_dir = match std::env::var("LISPERS_OUT_DIR") {
+        Ok(val) => val,
+        Err(_) => std::env::var("OUT_DIR").unwrap(),
+    };
+
+    let mut scenes_dir = Path::new(&std::env::var("CARGO_MANIFEST_DIR").unwrap())
+        .canonicalize()
+        .unwrap()
+        .join("scenes");
+
+    if !use_local_scenes {
+        let tgt_scenes_dir = Path::new(&out_dir).join("scenes");
+        if !no_copy {
+            copy_dir(&scenes_dir, &tgt_scenes_dir).expect("Failed to copy scenes directory");
+        }
+        scenes_dir = tgt_scenes_dir;
+    }
+
+    println!("cargo:rustc-env=SCENES_DIR={}", scenes_dir.display());
+}

flake.nix

@@ -79,7 +79,15 @@
           overlays = [rust-overlay.overlays.default];
         };
 
-        packages.lispers = cargoNix.workspaceMembers.lispers.build;
+        packages.lispers = cargoNix.workspaceMembers.lispers.build.overrideAttrs (attrs: {
+          preConfigure = ''
+            export LISPERS_OUT_DIR="$out"
+            export LISPERS_DONT_COPY_SCENES=1
+          '';
+          postInstall = ''
+            cp -r $src/scenes $out/scenes
+          '';
+        });
         packages.default = self'.packages.lispers;
         apps = {
           lisp_demo = {
@@ -94,7 +102,7 @@
             type = "app";
             program = "${self'.packages.lispers}/bin/rt_demo";
           };
-          rt_demo_lisp = {
+          rt_lisp_demo = {
             type = "app";
             program = "${self'.packages.lispers}/bin/rt_lisp_demo";
           };
@@ -106,7 +114,9 @@
         };
 
         devShells.default = pkgs.mkShell {
-          inputsFrom = [self'.packages.lispers];
+          shellHook = ''
+            export LISPERS_USE_LOCAL_SCENES=1
+          '';
           LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
           nativeBuildInputs = [rust-toolchain pkgs.pkg-config pkgs.ffmpeg_4];
           BINDGEN_EXTRA_CLANG_ARGS = [

src/bin/rt_lisp_demo.rs

@@ -1,37 +1,51 @@
+use std::collections::HashMap;
+use std::path::Path;
+
 use lispers::raytracer::lisp::mk_raytrace;
 use lispers_core::lisp::environment::EnvironmentLayer;
 use lispers_core::lisp::prelude::mk_prelude;
 use lispers_core::lisp::{eval, Environment};
 use lispers_core::parser::ExpressionStream;
 
+const SCENES_DIR: &str = env!("SCENES_DIR");
+
 fn main() {
-    let programs = [
+    println!("Loading scenes from directory: {}", SCENES_DIR);
-        "(set 'red (material (color 1 0 0) (color 1 0 0) (color 0.5 0 0) 50 0.25))",
+
-        "(set 'blue (material (color 0 0 1) (color 0 0 1) (color 0 0 0.6) 50 0.25))",
+    let mut scenes = HashMap::new();
-        "(set 'green (material (color 0 1 0) (color 0 1 0) (color 0 0.6 0) 50 0.25))",
+    for e in std::fs::read_dir(Path::new(SCENES_DIR)).expect("Failed to read scenes directory") {
-        "(set 'white (material (color 1 1 1) (color 1 1 1) (color 0.6 0.6 0.6) 100 0.5))",
+        let e = e.expect("Failed to read scene file");
-        "(set 'black (material (color 0 0 0) (color 0 0 0) (color 0.6 0.6 0.6) 100 0.5))",
+        let t = e.file_type().expect("Failed to read scene file type");
-        "(set 's1 (sphere (point 0 1 0) 1 blue))",
+        let n = e
-        "(set 's2 (sphere (point 2 0.5 2) 0.5 green))",
+            .file_name()
-        "(defun spiral-sphere (i n) (sphere (print (point (* 2 (cos (/ (* i 6.2) n))) 0.5 (* 2 (sin (/ (* i 6.2) n))))) 0.5 red))",
+            .into_string()
-        "(defun spiral (scn i n) (if (< i n) (scene-add (spiral scn (+ i 1) n) (spiral-sphere i n)) scn))",
+            .expect("Failed to read scene file name");
-        "(set 'p1 (checkerboard (point 0 0 0) (vector 0 1 0) black white 0.5 (vector 0.5 0 1)))",
+        if t.is_file() && n.starts_with("demo-") && n.ends_with(".lisp") {
-        "(set 'l1 (light (point 3 10 5) (color 1 1 1)))",
+            scenes.insert(n, e);
-        "(set 'l2 (light (point 2 10 5) (color 1 1 1)))",
+        }
-        "(set 'scn (scene (color 0.1 0.1 0.1) '(s1 s2 p1) '(l1 l2)))",
+    }
-        "(set 'scn (spiral scn 0.0 10.0))",
-        "(print scn)",
-        "(set 'cam (camera (point 0 3 6) (point 0 0 0) (vector 0 1 0) 40 1920 1080))",
-        "(render cam scn 5 4 \"rt-lisp-demo.png\")",
-    ];
 
     let mut layer = EnvironmentLayer::new();
     mk_prelude(&mut layer);
     mk_raytrace(&mut layer);
-
     let environment = Environment::from_layer(layer);
 
-    for r in ExpressionStream::from_char_stream(programs.iter().map(|p| p.chars()).flatten()) {
+    let args: Vec<_> = std::env::args().collect();
+
+    if args.len() != 2 {
+        println!("Usage: {} <scene-file.lisp>", args[0]);
+        println!("Available scene files:");
+        for name in scenes.keys() {
+            println!("  {}", name);
+        }
+        return;
+    }
+
+    for r in ExpressionStream::from_char_stream(
+        std::fs::read_to_string(scenes.get(&args[1]).expect("Scene file not found").path())
+            .expect("Failed to read scene file")
+            .chars(),
+    ) {
         match r {
             Err(err) => {
                 println!("ParserError: {:?}", err);