mirror of
https://github.com/bevyengine/bevy.git
synced 2026-05-06 06:06:42 -04:00
ickshonpe
6ca4769128
# Objective
Add responsive font sizes supporting rem and viewport units to
`bevy_text` with minimal changes to the APIs and systems.
## Solution
Introduce a new `FontSize` enum:
```rust
pub enum FontSize {
/// Font Size in logical pixels.
Px(f32),
/// Font size as a percentage of the viewport width.
Vw(f32),
/// Font size as a percentage of the viewport height.
Vh(f32),
/// Font size as a percentage of the smaller of the viewport width and height.
VMin(f32),
/// Font size as a percentage of the larger of the viewport width and height.
VMax(f32),
/// Font Size relative to the value of the `RemSize` resource.
Rem(f32),
}
```
This replaces the `f32` value of `TextFont`'s `font_size` field.
The viewport variants work the same way as their respective `Val`
counterparts.
`Rem` values are multiplied by the value of the `RemSize` resource
(which newtypes an `f32`).
`FontSize` provides an `eval` method that takes a logical viewport size
and rem base size and returns an `f32` logical font size. The resolved
logical font size is then written into the `Attributes` passed to Cosmic
Text by `TextPipeline::update_buffer`.
Any text implementation using `bevy_text` must now provide viewport and
rem base values when calling `TextPipeline::update_buffer` or
`create_measure`.
`Text2d` uses the size of the primary window to resolve viewport values
(or `Vec2::splat(1000)` if no primary window is found). This is a
deliberate compromise, a single `Text2d` can be rendered to multiple
viewports using `RenderLayers`, so it's difficult to find a rule for
which viewport size should be chosen.
### Change detection
`ComputedTextBlock` has two new fields: `uses_viewport_sizes` and
`uses_rem_sizes`, which are set to true in `TextPipeline::update_buffer`
iff any text section in the block uses viewport or rem font sizes,
respectively.
The `ComputedTextBlock::needs_rerender` method has been modified to take
take two bool parameters:
```rust
pub fn needs_rerender(
&self,
is_viewport_size_changed: bool,
is_rem_size_changed: bool,
) -> bool {
self.needs_rerender
|| (is_viewport_size_changed && self.uses_viewport_sizes)
|| (is_rem_size_changed && self.uses_rem_sizes)
}
```
This ensures that text reupdates will also be scheduled if one of the text section's uses a viewport font size and the local viewport size changed, or if one of the text section's uses a rem font size and the rem size changed.
#### Limitations
There are some limitations because we don't have any sort of font style inheritance yet:
* "rem" units aren't proper rem units, and just based on the value of a resource.
* "em" units are resolved based on inherited font size, so can't be implemented without inheritance support.
#### Notes
* This PR is quite small and not very technical. Reviewers don't need to be especially familiar with `bevy_text`. Most of the changes are to the examples.
* We could consider using `Val` instead of `FontSize`, then we could use `Val`'s constructor functions which would be much nicer, but some variants might not have sensible interpretations in both UI and Text2d contexts. Also we'd have to make `Val` accessible to `bevy_text`.
## Testing
The changes to the text systems are relatively trivial and easy to understand. I already added a minor change to the `text` example to use `Vh` font size for the "hello bevy" text in the bottom right corner. If you change the size of the window, you should see the text change size in response. The text initially flickers before it updates because of some unrelated asset/image changes that mean that font textures aren't ready until the frame after the text update that changes the font size.
Most of the example migrations were automated using regular expressions, and there are bound to be mistakes in those changes. It's infeasible to check every single example thoroughly, but it's early enough in the release cycle that I don't think we should be too worried if a few bugs slip in.
---------
Co-authored-by: Kevin Chen <chen.kevin.f@gmail.com>
104 lines
3.4 KiB
Rust
104 lines
3.4 KiB
Rust
//! Showcase how to use and configure FPS overlay.
|
|
|
|
use bevy::{
|
|
dev_tools::fps_overlay::{FpsOverlayConfig, FpsOverlayPlugin, FrameTimeGraphConfig},
|
|
prelude::*,
|
|
text::FontSmoothing,
|
|
};
|
|
|
|
struct OverlayColor;
|
|
|
|
impl OverlayColor {
|
|
const RED: Color = Color::srgb(1.0, 0.0, 0.0);
|
|
const GREEN: Color = Color::srgb(0.0, 1.0, 0.0);
|
|
}
|
|
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins((
|
|
DefaultPlugins,
|
|
FpsOverlayPlugin {
|
|
config: FpsOverlayConfig {
|
|
text_config: TextFont {
|
|
// Here we define size of our overlay
|
|
font_size: FontSize::Px(42.0),
|
|
// If we want, we can use a custom font
|
|
font: default(),
|
|
// We could also disable font smoothing,
|
|
font_smoothing: FontSmoothing::default(),
|
|
..default()
|
|
},
|
|
// We can also change color of the overlay
|
|
text_color: OverlayColor::GREEN,
|
|
// We can also set the refresh interval for the FPS counter
|
|
refresh_interval: core::time::Duration::from_millis(100),
|
|
enabled: true,
|
|
frame_time_graph_config: FrameTimeGraphConfig {
|
|
enabled: true,
|
|
// The minimum acceptable fps
|
|
min_fps: 30.0,
|
|
// The target fps
|
|
target_fps: 144.0,
|
|
},
|
|
},
|
|
},
|
|
))
|
|
.add_systems(Startup, setup)
|
|
.add_systems(Update, customize_config)
|
|
.run();
|
|
}
|
|
|
|
fn setup(mut commands: Commands) {
|
|
// We need to spawn a camera (2d or 3d) to see the overlay
|
|
commands.spawn(Camera2d);
|
|
|
|
// Instruction text
|
|
|
|
commands.spawn((
|
|
Text::new(concat!(
|
|
"Press 1 to toggle the overlay color.\n",
|
|
"Press 2 to decrease the overlay size.\n",
|
|
"Press 3 to increase the overlay size.\n",
|
|
"Press 4 to toggle the text visibility.\n",
|
|
"Press 5 to toggle the frame time graph."
|
|
)),
|
|
Node {
|
|
position_type: PositionType::Absolute,
|
|
bottom: px(12),
|
|
left: px(12),
|
|
..default()
|
|
},
|
|
));
|
|
}
|
|
|
|
fn customize_config(input: Res<ButtonInput<KeyCode>>, mut overlay: ResMut<FpsOverlayConfig>) {
|
|
if input.just_pressed(KeyCode::Digit1) {
|
|
// Changing resource will affect overlay
|
|
if overlay.text_color == OverlayColor::GREEN {
|
|
overlay.text_color = OverlayColor::RED;
|
|
} else {
|
|
overlay.text_color = OverlayColor::GREEN;
|
|
}
|
|
}
|
|
|
|
// The font size only adjustable when using `Px` units
|
|
if let FontSize::Px(mut px_font_size) = overlay.text_config.font_size {
|
|
if input.just_pressed(KeyCode::Digit2) {
|
|
px_font_size = (px_font_size - 2.).max(2.);
|
|
}
|
|
if input.just_pressed(KeyCode::Digit3) {
|
|
px_font_size += 2.;
|
|
}
|
|
if FontSize::Px(px_font_size) != overlay.text_config.font_size {
|
|
overlay.text_config.font_size = FontSize::Px(px_font_size);
|
|
}
|
|
}
|
|
|
|
if input.just_pressed(KeyCode::Digit4) {
|
|
overlay.enabled = !overlay.enabled;
|
|
}
|
|
if input.just_released(KeyCode::Digit5) {
|
|
overlay.frame_time_graph_config.enabled = !overlay.frame_time_graph_config.enabled;
|
|
}
|
|
}
|