rdpe 0.1.0

Reaction Diffusion Particle Engine - GPU particle simulations made easy
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Error types for RDPE.
//!
//! This module provides error types for GPU initialization, texture loading,
//! and other operations that can fail.

use std::fmt;

/// Errors that can occur during GPU initialization.
#[derive(Debug)]
pub enum GpuError {
    /// Failed to create a surface for rendering.
    SurfaceCreation(wgpu::CreateSurfaceError),
    /// No compatible GPU adapter found.
    NoAdapter,
    /// Failed to create GPU device.
    DeviceCreation(wgpu::RequestDeviceError),
    /// Failed to map buffer for reading.
    BufferMapping(String),
}

impl fmt::Display for GpuError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            GpuError::SurfaceCreation(e) => write!(f, "Failed to create GPU surface: {}", e),
            GpuError::NoAdapter => write!(f, "No compatible GPU adapter found. Ensure your system has a GPU with WebGPU/Vulkan/Metal/DX12 support."),
            GpuError::DeviceCreation(e) => write!(f, "Failed to create GPU device: {}", e),
            GpuError::BufferMapping(msg) => write!(f, "Failed to map GPU buffer: {}", msg),
        }
    }
}

impl std::error::Error for GpuError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            GpuError::SurfaceCreation(e) => Some(e),
            GpuError::DeviceCreation(e) => Some(e),
            _ => None,
        }
    }
}

impl From<wgpu::CreateSurfaceError> for GpuError {
    fn from(e: wgpu::CreateSurfaceError) -> Self {
        GpuError::SurfaceCreation(e)
    }
}

impl From<wgpu::RequestDeviceError> for GpuError {
    fn from(e: wgpu::RequestDeviceError) -> Self {
        GpuError::DeviceCreation(e)
    }
}

/// Errors that can occur during texture loading.
#[derive(Debug)]
pub enum TextureError {
    /// Failed to load image file.
    ImageLoad(image::ImageError),
    /// Failed to read file from disk.
    Io(std::io::Error),
}

impl fmt::Display for TextureError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TextureError::ImageLoad(e) => write!(f, "Failed to load image: {}", e),
            TextureError::Io(e) => write!(f, "Failed to read texture file: {}", e),
        }
    }
}

impl std::error::Error for TextureError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            TextureError::ImageLoad(e) => Some(e),
            TextureError::Io(e) => Some(e),
        }
    }
}

impl From<image::ImageError> for TextureError {
    fn from(e: image::ImageError) -> Self {
        TextureError::ImageLoad(e)
    }
}

impl From<std::io::Error> for TextureError {
    fn from(e: std::io::Error) -> Self {
        TextureError::Io(e)
    }
}

/// Errors that can occur when running a simulation.
#[derive(Debug)]
pub enum SimulationError {
    /// Failed to create event loop.
    EventLoop(winit::error::EventLoopError),
    /// Failed to create window.
    Window(winit::error::OsError),
    /// GPU initialization failed.
    Gpu(GpuError),
    /// No spawner function provided.
    NoSpawner,
}

impl fmt::Display for SimulationError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SimulationError::EventLoop(e) => write!(f, "Failed to create event loop: {}", e),
            SimulationError::Window(e) => write!(f, "Failed to create window: {}", e),
            SimulationError::Gpu(e) => write!(f, "GPU error: {}", e),
            SimulationError::NoSpawner => write!(f, "No spawner function provided. Use .with_spawner() to set one."),
        }
    }
}

impl std::error::Error for SimulationError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            SimulationError::EventLoop(e) => Some(e),
            SimulationError::Window(e) => Some(e),
            SimulationError::Gpu(e) => Some(e),
            SimulationError::NoSpawner => None,
        }
    }
}

impl From<winit::error::EventLoopError> for SimulationError {
    fn from(e: winit::error::EventLoopError) -> Self {
        SimulationError::EventLoop(e)
    }
}

impl From<winit::error::OsError> for SimulationError {
    fn from(e: winit::error::OsError) -> Self {
        SimulationError::Window(e)
    }
}

impl From<GpuError> for SimulationError {
    fn from(e: GpuError) -> Self {
        SimulationError::Gpu(e)
    }
}