proof-engine 0.1.1

A mathematical rendering engine for Rust. Every visual is the output of a mathematical function.
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

//! WebGPU-style backend abstraction layer for Proof Engine.
//!
//! This module provides a GPU-API-agnostic abstraction that could be backed by
//! OpenGL, Vulkan, Metal, WebGPU, or a pure-software fallback. No actual `wgpu`
//! crate dependency is used — everything is expressed as engine-level abstractions.
//!
//! # Sub-modules
//!
//! - [`backend`]  — Core GPU backend enum, capabilities, handle types, and context trait
//! - [`renderer`] — Multi-backend renderer with render passes and draw calls
//! - [`compute`]  — Compute shader dispatch, storage buffers, and CPU fallback
//! - [`shader_translate`] — Cross-compile shaders between GLSL, WGSL, SPIRV, HLSL, MSL
//! - [`abstraction`] — Unified `GpuDevice` / `GpuQueue` traits
//! - [`quality`]  — Adaptive quality management and benchmarking
//! - [`headless`] — Off-screen rendering, thumbnails, and server-side rendering

pub mod backend;
pub mod renderer;
pub mod compute;
pub mod shader_translate;
pub mod abstraction;
pub mod quality;
pub mod headless;

// Re-export the most-used items for convenience.
pub use backend::{
    GpuBackend, BackendCapabilities, BackendContext, BufferHandle, TextureHandle,
    ShaderHandle, PipelineHandle, ComputePipelineHandle, BufferUsage, TextureFormat,
    ShaderStage,
};
pub use renderer::MultiBackendRenderer;
pub use compute::ComputeContext;
pub use shader_translate::ShaderLanguage;
pub use abstraction::{GpuDevice, GpuQueue};
pub use quality::{QualityLevel, QualityManager};
pub use headless::HeadlessRenderer;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn smoke_test_module_imports() {
        let _backend = GpuBackend::Software;
        let _level = QualityLevel::Medium;
        let _lang = ShaderLanguage::GLSL;
    }

    #[test]
    fn detect_backend_returns_something() {
        let b = backend::detect_backend();
        // In a test environment we expect Software fallback
        assert!(matches!(
            b,
            GpuBackend::OpenGL
                | GpuBackend::Vulkan
                | GpuBackend::Metal
                | GpuBackend::WebGPU
                | GpuBackend::Software
        ));
    }
}