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
#![forbid(unsafe_code)] #![warn(missing_docs, unreachable_pub, missing_debug_implementations)] //! This crate provides the ability to annotate structs with a `#[derive(Inspectable)]`, //! which opens a debug interface using [egui](https://github.com/emilk/egui) where you can visually edit the values of your struct live. //! //! Your struct will then be available to you as a bevy resource. //! //! ## Example //! ```rust //! use bevy_inspector_egui::Inspectable; //! //! #[derive(Inspectable, Default)] //! struct Data { //! should_render: bool, //! text: String, //! #[inspectable(min = 42.0, max = 100.0)] //! size: f32, //! } //! ``` //! Add the [`InspectorPlugin`] to your App. //! ```rust,no_run //! use bevy_inspector_egui::InspectorPlugin; //! # use bevy::prelude::*; //! //! # #[derive(bevy_inspector_egui::Inspectable, Default)] struct Data {} //! fn main() { //! App::build() //! .add_plugins(DefaultPlugins) //! .add_plugin(InspectorPlugin::<Data>::new()) //! .add_system(your_system.system()) //! .run(); //! } //! //! # fn your_system() {} //! // fn your_system(data: Res<Data>) { /* */ } //! ``` //! #![allow(missing_docs)] mod impls; mod plugin; pub use bevy_egui::egui; /// Derives the [`Inspectable`](Inspectable) trait. pub use bevy_inspector_egui_derive::Inspectable; pub use plugin::InspectorPlugin; /// Attributes for the built-in [`Inspectable`](Inspectable) implementations pub mod options { pub use crate::impls::*; } #[non_exhaustive] #[derive(Default, Debug, Clone)] /// This type is passed to the [`Inspectable::ui`](Inspectable::ui) method /// to give access to the attributes specified in the `#[derive(Inspectable)]`. /// For an example of defining custom attributes, see the [docs of Inspectable](Inspectable::FieldOptions). pub struct Options<T> { /// The user defined options pub custom: T, } impl<T: Default> Options<T> { /// Create new options pub fn new(custom: T) -> Self { Options { custom } } } impl<T> Options<T> { fn map<U>(&self, f: impl Fn(&T) -> U) -> Options<U> { Options { custom: f(&self.custom), } } } /// This trait describes how a struct should be displayed. /// It can be derived for structs and enums, see the [crate-level docs](index.html) for how to do that. pub trait Inspectable { /// The `FieldOptions` associated type specifies what attributes can be passed to a field. /// See the following snippet for an example: /// ```rust /// # use bevy_inspector_egui::{egui, Inspectable, Options}; /// struct MyCustomType; /// # #[derive(Default)] /// struct MyWidgetOptions { a: f32, b: Option<String> } /// /// impl Inspectable for MyCustomType { /// type FieldOptions = MyWidgetOptions; /// /// fn ui(&mut self, _: &mut egui::Ui, options: Options<MyWidgetOptions>) { /// println!("a = {}, b = {:?}", options.custom.a, options.custom.b); /// } /// } /// /// // ... /// /// #[derive(Inspectable)] /// struct InspectorData { /// #[inspectable(a = 10.0, b = None)] /// value: MyCustomType, /// } /// ``` type FieldOptions: Default; /// This methods is responsible for building the egui ui. fn ui(&mut self, ui: &mut egui::Ui, options: Options<Self::FieldOptions>); }