astrelis-text 0.2.1

Text rendering module for the Astrelis game engine
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

/// Errors that can occur in the text rendering system.
#[derive(Debug, Clone)]
pub enum TextError {
    /// Font loading failed.
    FontLoadError(String),

    /// Font file not found.
    FontFileNotFound(std::path::PathBuf),

    /// Invalid font data.
    InvalidFontData(String),

    /// Lock was poisoned (RwLock/Mutex).
    LockPoisoned(String),

    /// Text shaping failed.
    ShapingError(String),

    /// Buffer allocation failed.
    BufferAllocationFailed(String),

    /// Texture atlas is full.
    AtlasFull {
        requested_width: u32,
        requested_height: u32,
        atlas_width: u32,
        atlas_height: u32,
    },

    /// GPU resource creation failed.
    GpuResourceError(String),

    /// Invalid text range.
    InvalidRange {
        start: usize,
        end: usize,
        text_len: usize,
    },

    /// Generic IO error.
    IoError(String),
}

impl std::fmt::Display for TextError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TextError::FontLoadError(msg) => write!(f, "Failed to load font: {}", msg),
            TextError::FontFileNotFound(path) => {
                write!(f, "Font file not found: {}", path.display())
            }
            TextError::InvalidFontData(msg) => write!(f, "Invalid font data: {}", msg),
            TextError::LockPoisoned(msg) => {
                write!(f, "Lock was poisoned (likely due to panic in another thread): {}", msg)
            }
            TextError::ShapingError(msg) => write!(f, "Text shaping failed: {}", msg),
            TextError::BufferAllocationFailed(msg) => {
                write!(f, "Buffer allocation failed: {}", msg)
            }
            TextError::AtlasFull {
                requested_width,
                requested_height,
                atlas_width,
                atlas_height,
            } => write!(
                f,
                "Texture atlas is full: requested {}x{} but atlas is {}x{}",
                requested_width, requested_height, atlas_width, atlas_height
            ),
            TextError::GpuResourceError(msg) => write!(f, "GPU resource error: {}", msg),
            TextError::InvalidRange { start, end, text_len } => write!(
                f,
                "Invalid text range: {}..{} (text length: {})",
                start, end, text_len
            ),
            TextError::IoError(msg) => write!(f, "IO error: {}", msg),
        }
    }
}

impl std::error::Error for TextError {}

impl From<std::io::Error> for TextError {
    fn from(err: std::io::Error) -> Self {
        TextError::IoError(err.to_string())
    }
}

impl<T> From<std::sync::PoisonError<T>> for TextError {
    fn from(err: std::sync::PoisonError<T>) -> Self {
        TextError::LockPoisoned(err.to_string())
    }
}

/// Result type for text operations.
pub type TextResult<T> = Result<T, TextError>;