bevy_debug_log 0.9.0

Allows viewing tracing debug log output inside the bevy app using vanilla bevy_ui.
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

use bevy_color::{palettes::css, prelude::*};
use bevy_ecs::prelude::*;
use bevy_log::{tracing::level_filters::LevelFilter, Level};
use core::fmt;

#[derive(Component, Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub(crate) struct DebugLogLevel(Level);

impl DebugLogLevel {
    pub const TRACE: Self = Self(Level::TRACE);
    pub const DEBUG: Self = Self(Level::DEBUG);
    pub const INFO: Self = Self(Level::INFO);
    pub const WARN: Self = Self(Level::WARN);
    pub const ERROR: Self = Self(Level::ERROR);

    pub fn title_case(&self) -> String {
        match self.0 {
            Level::TRACE => "Trace",
            Level::DEBUG => "Debug",
            Level::INFO => "Info",
            Level::WARN => "Warn",
            Level::ERROR => "Error",
        }
        .to_string()
    }
}

impl From<Level> for DebugLogLevel {
    fn from(level: Level) -> Self {
        Self(level)
    }
}

impl From<DebugLogLevel> for Level {
    fn from(log_level: DebugLogLevel) -> Self {
        log_level.0
    }
}

impl From<DebugLogLevel> for Srgba {
    fn from(log_level: DebugLogLevel) -> Self {
        match log_level.0 {
            Level::TRACE => css::MEDIUM_ORCHID,
            Level::DEBUG => css::DEEP_SKY_BLUE,
            Level::INFO => css::LIME,
            Level::WARN => css::YELLOW,
            Level::ERROR => css::RED,
        }
    }
}

impl From<DebugLogLevel> for Color {
    fn from(log_level: DebugLogLevel) -> Self {
        let color: Srgba = log_level.into();
        color.into()
    }
}

impl From<DebugLogLevel> for String {
    fn from(log_level: DebugLogLevel) -> Self {
        log_level.0.to_string()
    }
}

impl TryFrom<LevelFilter> for DebugLogLevel {
    type Error = ();

    fn try_from(level_filter: LevelFilter) -> Result<Self, Self::Error> {
        match level_filter {
            LevelFilter::TRACE => Ok(DebugLogLevel(Level::TRACE)),
            LevelFilter::DEBUG => Ok(DebugLogLevel(Level::DEBUG)),
            LevelFilter::INFO => Ok(DebugLogLevel(Level::INFO)),
            LevelFilter::WARN => Ok(DebugLogLevel(Level::WARN)),
            LevelFilter::ERROR => Ok(DebugLogLevel(Level::ERROR)),
            LevelFilter::OFF => Err(()),
        }
    }
}

impl fmt::Display for DebugLogLevel {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}