dear-imgui-rs 0.14.0

High-level Rust bindings to Dear ImGui v1.92.7 with docking, WGPU/GL backends, and extensions (ImPlot/ImPlot3D, ImNodes, ImGuizmo, file browser, reflection-based 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
85
86
87
88
89
90
91
92
93

use crate::internal::{DataType, DataTypeKind};
use crate::sys;

use super::SliderFlags;

pub(super) fn validate_slider_flags(caller: &str, flags: SliderFlags) {
    let bits = flags.bits();
    assert!(
        bits & (sys::ImGuiSliderFlags_WrapAround as i32) == 0,
        "{caller} does not support ImGuiSliderFlags_WrapAround; use DragFlags::WRAP_AROUND with drag widgets"
    );
    let unsupported = bits & !SliderFlags::all().bits();
    assert!(
        unsupported == 0,
        "{caller} received unsupported ImGuiSliderFlags bits: 0x{unsupported:X}"
    );
}

pub(super) fn validate_slider_range<Data: DataTypeKind>(caller: &str, min: &Data, max: &Data) {
    match Data::KIND {
        DataType::I8 | DataType::U8 | DataType::I16 | DataType::U16 => {}
        DataType::I32 => {
            let min = unsafe { *(min as *const Data as *const i32) };
            let max = unsafe { *(max as *const Data as *const i32) };
            let lower = i32::MIN / 2;
            let upper = i32::MAX / 2;
            assert!(
                (lower..=upper).contains(&min) && (lower..=upper).contains(&max),
                "{caller} i32/isize range endpoints must stay within i32::MIN/2..=i32::MAX/2"
            );
        }
        DataType::U32 => {
            let min = unsafe { *(min as *const Data as *const u32) };
            let max = unsafe { *(max as *const Data as *const u32) };
            let upper = u32::MAX / 2;
            assert!(
                min <= upper && max <= upper,
                "{caller} u32/usize range endpoints must be <= u32::MAX/2"
            );
        }
        DataType::I64 => {
            let min = unsafe { *(min as *const Data as *const i64) };
            let max = unsafe { *(max as *const Data as *const i64) };
            let lower = i64::MIN / 2;
            let upper = i64::MAX / 2;
            assert!(
                (lower..=upper).contains(&min) && (lower..=upper).contains(&max),
                "{caller} i64/isize range endpoints must stay within i64::MIN/2..=i64::MAX/2"
            );
        }
        DataType::U64 => {
            let min = unsafe { *(min as *const Data as *const u64) };
            let max = unsafe { *(max as *const Data as *const u64) };
            let upper = u64::MAX / 2;
            assert!(
                min <= upper && max <= upper,
                "{caller} u64/usize range endpoints must be <= u64::MAX/2"
            );
        }
        DataType::F32 => {
            let min = unsafe { *(min as *const Data as *const f32) };
            let max = unsafe { *(max as *const Data as *const f32) };
            assert!(
                min.is_finite()
                    && max.is_finite()
                    && (-f32::MAX / 2.0..=f32::MAX / 2.0).contains(&min)
                    && (-f32::MAX / 2.0..=f32::MAX / 2.0).contains(&max),
                "{caller} f32 range endpoints must be finite and stay within -f32::MAX/2..=f32::MAX/2"
            );
        }
        DataType::F64 => {
            let min = unsafe { *(min as *const Data as *const f64) };
            let max = unsafe { *(max as *const Data as *const f64) };
            assert!(
                min.is_finite()
                    && max.is_finite()
                    && (-f64::MAX / 2.0..=f64::MAX / 2.0).contains(&min)
                    && (-f64::MAX / 2.0..=f64::MAX / 2.0).contains(&max),
                "{caller} f64 range endpoints must be finite and stay within -f64::MAX/2..=f64::MAX/2"
            );
        }
    }
}

pub(super) fn validate_slider_preconditions<Data: DataTypeKind>(
    caller: &str,
    min: &Data,
    max: &Data,
    flags: SliderFlags,
) {
    validate_slider_flags(caller, flags);
    validate_slider_range(caller, min, max);
}