enginerenderer 0.0.1

A zero-dependency offline rendering engine in pure Rust — CPU path tracing, BVH acceleration, 16-band spectral rendering, PBR materials, animation & video export.
Documentation 
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

use std::path::PathBuf;

use super::glb_loader::GlbLoader;
use super::obj_loader::ObjLoader;
use crate::core::engine::rendering::mesh::asset::MeshAsset;

#[derive(Debug, Clone)]
pub struct ContentBundle {
    pub primary_meshes: Vec<MeshAsset>,
    pub cinematic_meshes: Vec<MeshAsset>,
}

#[derive(Debug, Default, Clone, Copy)]
pub struct ContentLoader;

impl ContentLoader {
    pub fn load_showcase_bundle(&self) -> ContentBundle {
        let obj_loader = ObjLoader;
        let glb_loader = GlbLoader;
        let mut primary_meshes = Vec::new();
        let mut cinematic_meshes = Vec::new();

        for root in self.asset_roots() {
            primary_meshes.extend(obj_loader.load_directory(&root).unwrap_or_default());
            cinematic_meshes.extend(glb_loader.load_directory(&root).unwrap_or_default());
        }

        if primary_meshes.is_empty() {
            primary_meshes = vec![
                MeshAsset::procedural_asteroid("hero_asteroid", 1.2, 5),
                MeshAsset::procedural_asteroid("orbital_fragment", 0.6, 4),
            ];
        }

        if cinematic_meshes.is_empty() {
            cinematic_meshes = vec![
                MeshAsset::procedural_asteroid("background_massive", 2.1, 5),
                MeshAsset::procedural_asteroid("debris_cluster", 0.42, 4),
            ];
        }

        ContentBundle {
            primary_meshes,
            cinematic_meshes,
        }
    }

    fn asset_roots(&self) -> Vec<PathBuf> {
        let mut candidates = vec![
            PathBuf::from("assets"),
            PathBuf::from("models"),
            PathBuf::from("content"),
        ];

        if let Ok(current_dir) = std::env::current_dir() {
            candidates.push(current_dir.join("assets"));
            candidates.push(current_dir.join("models"));
            candidates.push(current_dir.join("content"));
        }

        let mut roots = Vec::new();
        for candidate in candidates {
            if candidate.is_dir() && !roots.iter().any(|existing| existing == &candidate) {
                roots.push(candidate);
            }
        }

        roots
    }
}