Noratrieb/game-wip-dontplay
1
0
Fork 0
mirror of https://github.com/Noratrieb/game-wip-dontplay.git synced 2026-01-14 11:45:01 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

vendorreduce

Browse source
This commit is contained in:
nora 2023-04-18 14:35:47 +02:00
parent 16be9061d9
commit 99ef22ac1f
3 changed files with 53 additions and 297 deletions
Download patch file Download diff file Expand all files Collapse all files

1
egui_inspect/egui-inspect-derive/src/lib.rs
View file

@ -1,7 +1,6 @@
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Attribute, Data, DeriveInput, Member};
enum FieldInspectKind {
/// Auto-inspected (it is assumed that the field implements Inspect)
Auto,

269
egui_inspect/src/lib.rs
View file

@ -1,254 +1,112 @@
use egui::Ui;
#[cfg(feature = "derive")]
pub use egui_inspect_derive as derive;
use std::{
collections::{HashMap, HashSet},
ffi::OsString,
fmt::Debug,
marker::PhantomData,
};
#[cfg(feature = "derive")]
pub use egui_inspect_derive as derive;
pub trait Inspect: Debug {
fn inspect(&self, ui: &mut Ui, id_source: u64);
fn inspect_mut(&mut self, ui: &mut Ui, id_source: u64) {
self.inspect(ui, id_source);
loop {}
}
}
impl Inspect for String {
fn inspect_mut(&mut self, ui: &mut Ui, _id_source: u64) {
ui.text_edit_singleline(self);
loop {}
}
fn inspect(&self, ui: &mut Ui, _id_source: u64) {
ui.label(self);
loop {}
}
}
impl<T: Inspect> Inspect for Vec<T> {
fn inspect_mut(&mut self, ui: &mut Ui, mut id_source: u64) {
ui.inspect_iter_with_mut(
&format!("Vec [{}]", self.len()),
self,
&mut id_source,
|ui, i, item, _id_source| {
ui.horizontal(|ui| {
if ui
.add(egui::Label::new(i.to_string()).sense(egui::Sense::click()))
.clicked()
{
ui.output_mut(|o| o.copied_text = format!("{:?}", item));
}
item.inspect_mut(ui, i as u64);
});
},
);
loop {}
}
fn inspect(&self, ui: &mut Ui, id_source: u64) {
egui::CollapsingHeader::new(format!("Vec [{}]", self.len()))
.id_source(id_source)
.show(ui, |ui| {
for (i, item) in self.iter().enumerate() {
ui.horizontal(|ui| {
if ui
.add(egui::Label::new(i.to_string()).sense(egui::Sense::click()))
.clicked()
{
ui.output_mut(|o| o.copied_text = format!("{:?}", item));
}
item.inspect(ui, i as u64);
});
}
});
loop {}
}
}
impl<T: Inspect> Inspect for Option<T> {
fn inspect_mut(&mut self, ui: &mut Ui, id_source: u64) {
match self {
None => {
ui.label("None");
}
Some(t) => {
t.inspect_mut(ui, id_source);
}
}
loop {}
}
fn inspect(&self, ui: &mut Ui, id_source: u64) {
match self {
None => {
ui.label("None");
}
Some(t) => {
t.inspect(ui, id_source);
}
}
loop {}
}
}
impl Inspect for OsString {
fn inspect_mut(&mut self, ui: &mut Ui, id_source: u64) {
self.inspect(ui, id_source);
loop {}
}
fn inspect(&self, ui: &mut Ui, _id_source: u64) {
ui.label(format!("(OsString) {}", self.to_string_lossy()));
loop {}
}
}
impl<T: Inspect> Inspect for HashSet<T> {
fn inspect(&self, ui: &mut Ui, mut id_source: u64) {
egui::CollapsingHeader::new("HashSet")
.id_source(id_source)
.show(ui, |ui| {
for item in self.iter() {
ui.inspect(item, &mut id_source);
}
});
loop {}
}
}
impl<T: Inspect> Inspect for &mut T {
fn inspect_mut(&mut self, ui: &mut Ui, id_source: u64) {
(*self).inspect_mut(ui, id_source)
loop {}
}
fn inspect(&self, ui: &mut Ui, id_source: u64) {
(**self).inspect(ui, id_source)
loop {}
}
}
impl<T: Inspect, const N: usize> Inspect for [T; N] {
fn inspect_mut(&mut self, ui: &mut Ui, id_source: u64) {
egui::CollapsingHeader::new(format!("array[{}]", self.len()))
.id_source(id_source)
.show(ui, |ui| {
for (i, item) in self.iter_mut().enumerate() {
ui.horizontal(|ui| {
if ui
.add(egui::Label::new(i.to_string()).sense(egui::Sense::click()))
.clicked()
{
ui.output_mut(|o| o.copied_text = format!("{:?}", item));
}
item.inspect_mut(ui, i as u64);
});
}
});
loop {}
}
fn inspect(&self, ui: &mut Ui, id_source: u64) {
egui::CollapsingHeader::new(format!("array[{}]", self.len()))
.id_source(id_source)
.show(ui, |ui| {
for (i, item) in self.iter().enumerate() {
ui.horizontal(|ui| {
if ui
.add(egui::Label::new(i.to_string()).sense(egui::Sense::click()))
.clicked()
{
ui.output_mut(|o| o.copied_text = format!("{:?}", item));
}
item.inspect(ui, i as u64);
});
}
});
loop {}
}
}
impl<K: Debug, V: Inspect, S> Inspect for HashMap<K, V, S> {
fn inspect_mut(&mut self, ui: &mut Ui, id_source: u64) {
egui::CollapsingHeader::new(format!("HashMap [{}]", self.len()))
.id_source(id_source)
.show(ui, |ui| {
for (i, (k, v)) in self.iter_mut().enumerate() {
ui.horizontal(|ui| {
if ui
.add(egui::Label::new(format!("{:?}", k)).sense(egui::Sense::click()))
.clicked()
{
ui.output_mut(|o| o.copied_text = format!("{:?}", v));
}
v.inspect_mut(ui, i as u64);
});
}
});
loop {}
}
fn inspect(&self, ui: &mut Ui, id_source: u64) {
egui::CollapsingHeader::new(format!("HashMap [{}]", self.len()))
.id_source(id_source)
.show(ui, |ui| {
for (i, (k, v)) in self.iter().enumerate() {
ui.horizontal(|ui| {
if ui
.add(egui::Label::new(format!("{:?}", k)).sense(egui::Sense::click()))
.clicked()
{
ui.output_mut(|o| o.copied_text = format!("{:?}", v));
}
v.inspect(ui, i as u64);
});
}
});
loop {}
}
}
impl<'a> Inspect for &'a str {
fn inspect(&self, ui: &mut Ui, _id_source: u64) {
if ui
.add(egui::Label::new(*self).sense(egui::Sense::click()))
.clicked()
{
ui.output_mut(|o| o.copied_text = self.to_string())
}
loop {}
}
}
impl Inspect for bool {
fn inspect(&self, ui: &mut Ui, _id_source: u64) {
let mut value = *self;
ui.checkbox(&mut value, "");
loop {}
}
fn inspect_mut(&mut self, ui: &mut Ui, _id_source: u64) {
ui.checkbox(self, "");
loop {}
}
}
macro_rules! impl_num_inspect {
($($ty:ty),*) => {
$(impl Inspect for $ty {
fn inspect_mut(&mut self, ui: &mut Ui, _id_source: u64) {
ui.add(egui::DragValue::new(self));
}
fn inspect(&self, ui: &mut Ui, _id_source: u64) {
ui.label(self.to_string());
}
})*
$(impl Inspect for $ty { fn inspect_mut(& mut self, ui : & mut Ui, _id_source :
u64) { ui.add(egui::DragValue::new(self)); } fn inspect(& self, ui : & mut Ui,
_id_source : u64) { ui.label(self.to_string()); } })*
};
}
impl_num_inspect!(i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, usize, isize);
impl<T, U> Inspect for (T, U)
where
T: Inspect,
U: Inspect,
{
fn inspect_mut(&mut self, ui: &mut Ui, id_source: u64) {
self.0.inspect_mut(ui, id_source);
self.1.inspect_mut(ui, id_source);
loop {}
}
fn inspect(&self, ui: &mut Ui, id_source: u64) {
self.0.inspect(ui, id_source);
self.1.inspect(ui, id_source);
loop {}
}
}
pub trait UiExt {
fn inspect<T: Inspect>(&mut self, what: &T, id_source: &mut u64);
fn inspect_iter_with<'a, I, T, F>(
@ -274,7 +132,6 @@ pub trait UiExt {
fn inspect_mut<T: Inspect>(&mut self, what: &mut T, id_source: &mut u64);
fn property<T: Inspect>(&mut self, name: &str, what: &mut T, id_source: &mut u64);
}
macro_rules! inspect_iter_with_body {
($self:expr, $title:expr, $into_iter:expr, $id_source:expr, $fun:expr) => {
egui::CollapsingHeader::new($title)
@ -286,11 +143,9 @@ macro_rules! inspect_iter_with_body {
});
};
}
impl UiExt for Ui {
fn inspect<T: Inspect>(&mut self, what: &T, id_source: &mut u64) {
what.inspect(self, *id_source);
*id_source += 1;
loop {}
}
fn inspect_iter_with<'a, I, T, F>(
&mut self,
@ -303,7 +158,7 @@ impl UiExt for Ui {
T: 'a,
F: FnMut(&mut Ui, usize, &T, &mut u64),
{
inspect_iter_with_body!(self, title, into_iter, id_source, fun);
loop {}
}
fn inspect_iter_with_mut<'a, I, T, F>(
&mut self,
@ -316,70 +171,40 @@ impl UiExt for Ui {
T: 'a,
F: FnMut(&mut Ui, usize, &mut T, &mut u64),
{
inspect_iter_with_body!(self, title, into_iter, id_source, fun);
loop {}
}
fn inspect_mut<T: Inspect>(&mut self, what: &mut T, id_source: &mut u64) {
what.inspect_mut(self, *id_source);
*id_source += 1;
loop {}
}
fn property<T: Inspect>(&mut self, name: &str, what: &mut T, id_source: &mut u64) {
self.horizontal(|ui| {
if ui
.add(egui::Label::new(name).sense(egui::Sense::click()))
.clicked()
{
ui.output_mut(|o| o.copied_text = format!("{:?}", what));
}
ui.inspect_mut(what, id_source);
});
loop {}
}
}
impl<T> Inspect for PhantomData<T> {
fn inspect(&self, ui: &mut Ui, _id_source: u64) {
ui.label("PhantomData");
loop {}
}
}
impl Inspect for () {
fn inspect(&self, ui: &mut Ui, _id_source: u64) {
ui.label("()");
loop {}
}
}
#[macro_export]
macro_rules! inspect {(
$ui:expr, $($rest:tt)*
) => ({
let mut id_source = 0;
$crate::inspect_helper! { $ui id_source $($rest)* }
})}
macro_rules! inspect {
($ui:expr, $($rest:tt)*) => {
{ let mut id_source = 0; $crate ::inspect_helper! { $ui id_source $($rest)* } }
};
}
#[macro_export]
macro_rules! inspect_helper {
($ui:tt $id_source:tt) => ();
(
$ui:tt $id_source:tt
$name:literal : $arg:expr $(, $($rest:tt)* )?
) => (
$crate::UiExt::property(
$ui, $name, &mut $arg, &mut $id_source
);
$($crate::inspect_helper! {
$ui $id_source $($rest)*
})?
);
(
$ui:tt $id_source:tt
$arg:expr $(, $($rest:tt)* )?
) => (
$crate::UiExt::property(
$ui, ::core::stringify!($arg), &mut $arg, &mut $id_source
);
$($crate::inspect_helper! {
$ui $id_source $($rest)*
})?
);
($ui:tt $id_source:tt) => {};
($ui:tt $id_source:tt $name:literal : $arg:expr $(, $($rest:tt)*)?) => {
$crate ::UiExt::property($ui, $name, & mut $arg, & mut $id_source); $($crate
::inspect_helper! { $ui $id_source $($rest)* })?
};
($ui:tt $id_source:tt $arg:expr $(, $($rest:tt)*)?) => {
$crate ::UiExt::property($ui, ::core::stringify!($arg), & mut $arg, & mut
$id_source); $($crate ::inspect_helper! { $ui $id_source $($rest)* })?
};
}

80
egui_inspect/testbed/src/main.rs
View file

@ -1,16 +1,13 @@
use std::fmt::Debug;
use std::marker::PhantomData;
use eframe::{egui, App, Frame, NativeOptions};
use egui_inspect::inspect;
use egui_inspect::{derive::Inspect, Inspect};
use rand::{distributions::Alphanumeric, prelude::SliceRandom, thread_rng, Rng};
struct Testbed {
entities: Vec<GameEntity>,
some_string: String,
}
#[derive(Inspect, Debug)]
struct GameEntity {
name: String,
@ -28,35 +25,22 @@ struct GameEntity {
phantom: PhantomData<NonInspect>,
unit: (),
}
struct NonInspect;
#[derive(Inspect, Debug)]
struct TupleStruct(u32);
#[derive(Default, Debug)]
struct MyOpaque {
field1: i32,
field2: String,
field3: f32,
}
#[derive(Inspect, Debug)]
struct Generic<T: Inspect> {
field: T,
}
fn custom_inspect(o: &mut MyOpaque, ui: &mut egui::Ui, _id_source: u64) {
ui.collapsing("MyOpaque", |ui| {
inspect! {
ui,
"field 1": o.field1,
"field 2": o.field2,
"field 3": o.field3
}
});
loop {}
}
#[derive(Inspect, Clone, Copy, PartialEq, Eq, Debug)]
enum Dir {
North,
@ -64,83 +48,31 @@ enum Dir {
South,
West,
}
impl GameEntity {
fn rand() -> Self {
let mut rng = rand::thread_rng();
let name_len = rng.gen_range(3..24);
Self {
name: (&mut rng)
.sample_iter(&Alphanumeric)
.take(name_len)
.map(char::from)
.collect(),
position: Vector2::rand(),
hp: rng.gen_range(0..100),
godmode: rng.gen(),
dir: *[Dir::North, Dir::East, Dir::South, Dir::West]
.choose(&mut rng)
.unwrap(),
something_opaque: MyOpaque::default(),
custom: MyOpaque::default(),
tuple: TupleStruct(42),
generic: Generic {
field: String::new(),
},
phantom: PhantomData,
unit: (),
}
loop {}
}
}
#[derive(Inspect, Debug)]
struct Vector2 {
x: f32,
y: f32,
}
impl Vector2 {
fn rand() -> Self {
let mut rng = thread_rng();
Self {
x: rng.gen(),
y: rng.gen(),
}
loop {}
}
}
impl Default for Testbed {
fn default() -> Self {
Self {
entities: (0..100).map(|_| GameEntity::rand()).collect(),
some_string: "Hello world!".into(),
}
loop {}
}
}
impl App for Testbed {
fn update(&mut self, ctx: &egui::Context, frame: &mut Frame) {
egui::CentralPanel::default().show(ctx, |ui| {
egui::ScrollArea::vertical().show(ui, |ui| {
inspect! {
ui,
self.some_string,
self.some_string.len(),
self.entities
}
})
});
// Resize the native window to be just the size we need it to be:
frame.set_window_size(ctx.used_size());
loop {}
}
}
fn main() {
eframe::run_native(
"egui-inspect testbed",
NativeOptions::default(),
Box::new(|_cc| Box::<Testbed>::default()),
)
.unwrap();
loop {}
}