非官方 Bevy 作弊书04-06

# Enable max optimizations for dependencies, but not for our code:
# 为依赖项启用最大优化，但不包括我们的代码:
[profile.dev.package."*"]
opt-level = 3

# Enable only a small amount of optimization in debug mode
# 在调试模式下只进行少量优化
[profile.dev]
opt-level = 1

非官方 Bevy 作弊书

5.1 坐标系

2D 、 3D 场景和摄像机

Bevy 在游戏世界中使用右手 Y 向上坐标系。为了保持一致性，3D 和 2D 的坐标系相同。

用 2D 来解释最简单：

• X 轴从左向右（+X 指向右侧）。
• Y 轴从下到上（+Y 指向上）。
• Z 轴从远到近（+Z 指向您，在屏幕外）。
• 对于 2D，默认情况下原点 (X=0.0；Y=0.0) 位于屏幕中心。

当您使用 2D 精灵时，您可以将背景放在 Z=0.0 上，并将其他精灵放置在增加的正 Z 坐标处，以将它们分层在顶部。

在 3D 中，轴的方向相同：

• Y 点向上
• 前进方向为-Z

这是右手坐标系。您可以使用右手的手指来可视化 3 个轴：拇指=X、食指=Y、中=Z。

它与Godot、Maya、OpenGL 相同。与Unity相比，Z轴是倒置的。

（图形经许可修改和使用；原创作者：@FreyaHolmer）

用户界面

对于 UI，Bevy 遵循与大多数其他 UI 工具包、Web 等相同的约定。

• 原点位于屏幕左上角
• Y轴指向下方
• X 从 0.0（屏幕左边缘）到屏幕像素数（屏幕右边缘）
• Y 从 0.0（屏幕顶部边缘）到屏幕像素数（屏幕底部边缘）

这些单位表示逻辑（针对 DPI 缩放进行补偿）屏幕像素。

UI 布局从上到下流动，类似于网页。

光标和屏幕

如上所述，光标位置和任何其他窗口（屏幕空间）坐标遵循与 UI 相同的约定。

非官方 Bevy 作弊书

5.2 变换

相关官方示例：?transform、?translation、?rotation、?3d_rotation、?scale、?move_sprite、?parenting、任何生成 2D 或 3D 对象的内容。

首先，如果您是游戏开发新手，请快速定义一下：

变换允许您将对象放置在游戏世界中。它是对象的“平移”（位置/坐标）、“旋转”和“缩放”（大小调整）的组合。

您可以通过修改平移来移动对象，通过修改旋转来旋转对象，并通过修改比例来使对象变大或变小。

// To simply position something at specific coordinates
// 简单地将某些东西定位到特定的坐标
let xf_pos567 = Transform::from_xyz(5.0, 6.0, 7.0);

// To scale an object, making it twice as big in all dimensions
// 缩放对象，使其在所有维度上都是原来的两倍大
let xf_scale = Transform::from_scale(Vec3::splat(2.0));

// To rotate an object in 2D (Z-axis rotation) by 30°
// 在2D (z轴旋转)中旋转对象30°
// (angles are in radians! must convert from degrees!)
// (角度是以弧度表示的!必须从度转换!)
let xf_rot2d = Transform::from_rotation(Quat::from_rotation_z((30.0_f32).to_radians()));

// 3D rotations can be complicated; explore the methods available on `Quat`
// 3D旋转可能很复杂;探索`Quat`上可用的方法

// Simple 3D rotation by Euler-angles (X, Y, Z)
// 简单的三维欧拉角旋转(X, Y, Z)
let xf_rot2d = Transform::from_rotation(Quat::from_euler(
    EulerRot::XYZ,
    (20.0_f32).to_radians(),
    (10.0_f32).to_radians(),
    (30.0_f32).to_radians(),
));

// Everything:
// 所有的:
let xf = Transform::from_xyz(1.0, 2.0, 3.0)
    .with_scale(Vec3::new(0.5, 0.5, 1.0))
    .with_rotation(Quat::from_rotation_y(0.125 * std::f32::consts::PI));

变换组件

在 Bevy 中，变换由两个?组件表示：?Transform和GlobalTransform。

任何代表游戏世界中对象的实体都需要两者兼而有之。Bevy 的所有内置捆绑类型都 包含它们。

如果您在不使用这些捆绑包的情况下创建自定义实体，则可以使用以下方法之一来确保您不会错过它们：

• SpatialBundle用于变换+可见性
• TransformBundle仅用于变换

fn spawn_special_entity(
    mut commands: Commands,
) {
    // create an entity that does not use one of the common Bevy bundles,
    // 创建一个不使用普通Bevy bundle的实体，
    // but still needs transforms and visibility
    // 但仍然需要转换和可见性
    commands.spawn((
        ComponentA,
        ComponentB,
        SpatialBundle {
            transform: Transform::from_scale(Vec3::splat(3.0)),
            visibility: Visibility::Hidden,
            ..Default::default()
        },
    ));
}

Transform

Transform是您通常使用的内容。它包含struct平移、旋转和缩放。要读取或操作这些值，请使用?查询从您的系统访问它。

如果实体有父级，则该Transform?组件是相对于父级的。这意味着子对象将与父对象一起移动/旋转/缩放。

fn inflate_balloons(
    mut query: Query<&mut Transform, With<Balloon>>,
    keyboard: Res<Input<KeyCode>>,
) {
    // every time the Spacebar is pressed,
    // 每次按空格键时，
    // make all the balloons in the game bigger by 25%
    // 让游戏中的所有气球变大25%
    if keyboard.just_pressed(KeyCode::Space) {
        for mut transform in &mut query {
            transform.scale *= 1.25;
        }
    }
}

fn throwable_fly(
    time: Res<Time>,
    mut query: Query<&mut Transform, With<ThrowableProjectile>>,
) {
    // every frame, make our projectiles fly across the screen and spin
    // 每一帧，让我们的投射物在屏幕上飞行并旋转
    for mut transform in &mut query {
        // do not forget to multiply by the time delta!
        // 别忘了乘以时间delta!
        // this is required to move at the same speed regardless of frame rate!
        // 无论帧速率如何，它都要求以相同的速度移动!
        transform.translation.x += 100.0 * time.delta_seconds();
        transform.rotate_z(2.0 * time.delta_seconds());
    }
}

GlobalTransform

GlobalTransform代表着在世界上的绝对全球地位。

如果该实体没有父级，则这将匹配Transform。

GlobalTransform的值由 Bevy在内部计算/管理?（?“变换传播”?）。

与 Transform不同的是，平移/旋转/缩放不能直接访问。数据以优化的方式存储（使用Affine3A），并且可以在层次结构中进行无法表示为简单转换的复杂转换。例如，跨多个父级的旋转和缩放的组合会导致剪切。

如果您想尝试将GlobalTransformback 转换为可行的平移/旋转/缩放表示，您可以尝试以下方法：

• .translation()
• .to_scale_rotation_translation()（可能无效）
• .compute_transform()（可能无效）

变换传播

这两个组件由一组内部系统（“变换传播系统”）同步，该系统按时间表
PostUpdate?运行

注意：当您改变Transform? ?时，?GlobalTransform不会立即更新。在变换传播系统运行之前，它们将不同步。

如果您需要直接使用GlobalTransform?，您应该将您的?系统添加到PostUpdate计划中并在 后订购
?TransformSystem::TransformPropagate之后对其进行排序。。

/// Print the up-to-date global coordinates of the player
/// 打印玩家最新的全局坐标
fn debug_globaltransform(
    query: Query<&GlobalTransform, With<Player>>,
) {
    let gxf = query.single();
    debug!("Player at: {:?}", gxf.translation());
}

// the label to use for ordering
// 用于排序的标签
use bevy::transform::TransformSystem;

app.add_systems(PostUpdate,
    debug_globaltransform
        // we want to read the GlobalTransform after
?       // 之后我们要读取GlobalTransform
        // it has been updated by Bevy for this frame
?       // 这个帧已经被Bevy更新了
        .after(TransformSystem::TransformPropagate)
);

TransformHelper

如果您需要在转换传播之前运行的系统GlobalTransform?中获取最新的GlobalTransform信息，则可以使用特殊的TransformHelper?系统参数。TransformHelper?

GlobalTransform它允许您根据需要立即计算特定实体 。

这可能有用的一个例子是让相机跟随屏幕上的实体的系统。您需要更新相机的?Transform（这意味着您必须在 Bevy 的变换传播之前执行此操作，以便它可以考虑相机的新变换），但您还需要知道您正在跟踪的实体的当前最新位置。

fn camera_look_follow(
    q_target: Query<Entity, With<MySpecialMarker>>,
    mut transform_params: ParamSet<(
        TransformHelper,
        Query<&mut Transform, With<MyGameCamera>>,
    )>,
) {
    // get the Entity ID we want to target
?   // 获取我们想要定位的实体ID
    let e_target = q_target.single();
    // compute its actual current GlobalTransform
?   // 计算它实际的当前GlobalTransform
    // (could be Err if entity doesn't have transforms)
?   // (如果实体没有变形，可能会出错)
    let Ok(global) = transform_params.p0().compute_global_transform(e_target) else {
        return;
    };
    // get camera transform and make it look at the global translation
?   // 获取相机变换并使其查看全局转换
    transform_params.p1().single_mut().look_at(global.translation(), Vec3::Y);
}

在内部，TransformHelper其行为类似于两个只读查询。它需要访问Parent?和Transform组件才能完成其工作。它会与我们的其他&mut Transform查询冲突。这就是为什么我们必须?在上面的示例中使用参数集。

注意：如果过度使用TransformHelper，可能会成为性能问题。它为您计算全局变换，但不会更新存储在实体的?GlobalTransform中存储的数据GlobalTransform.?Bevy 稍后仍将在变换传播期间再次执行相同的计算。它导致重复性工作。如果您的系统可以在变换传播后运行，因此它可以在 Bevy 更新后读取值，那么您应该更愿意这样做，而不是使用TransformHelper.

非官方 Bevy 作弊书

5.3 能见度

相关官方例子：?parenting.

可见性用于控制是否渲染某些内容。如果你想让一个实体存在于世界中，只是不被显示，你可以隐藏它。

/// Prepare the game map, but do not display it until later
/// 准备游戏地图，但稍后再显示它

fn setup_map_hidden(
    mut commands: Commands,
) {
    commands.spawn((
        GameMapEntity,
        SceneBundle {
            scene: todo!(),
            visibility: Visibility::Hidden,
            ..Default::default()
        },
    ));
}

/// When everything is ready, un-hide the game map
/// 当一切准备就绪，取消隐藏游戏地图
fn reveal_map(
    mut query: Query<&mut Visibility, With<GameMapEntity>>,
) {
    let mut vis_map = query.single_mut();
    *vis_map = Visibility::Visible;
}

可见性组件

在 Bevy 中，可见性由多个?组件表示：

• Visibility：面向用户的切换开关（您可以在此处设置所需的内容）
• InheritedVisibility：Bevy 使用它来跟踪任何父实体的状态
• ViewVisibility：Bevy 使用它来跟踪实体是否应该实际显示

任何代表游戏世界中可渲染对象的实体都需要拥有它们。Bevy 的所有内置捆绑类型都包含它们。

如果您在不使用这些捆绑包的情况下创建自定义实体，则可以使用以下方法之一来确保您不会错过它们：

• SpatialBundle用于变换+可见性
• VisibilityBundle只是为了可见性

fn spawn_special_entity(
    mut commands: Commands,
) {
    // create an entity that does not use one of the common Bevy bundles,
    // 创建一个不使用普通Bevy bundle的实体，
    // but still needs transforms and visibility
    // 但仍然需要转换和可见性
    commands.spawn((
        ComponentA,
        ComponentB,
        SpatialBundle {
            transform: Transform::from_scale(Vec3::splat(3.0)),
            visibility: Visibility::Hidden,
            ..Default::default()
        },
    ));
}

如果您没有正确执行此操作（例如，您仅手动添加Visibility?组件并忘记其他组件，因为您不使用捆绑包），您的实体将不会呈现！

Visibility

Visibility是“面向用户的切换”。您可以在此处指定当前实体所需的内容：

• Inherited（默认）：根据父级显示/隐藏? ?，
• Visible：始终显示实体，无论父实体如何
• Hidden：始终隐藏实体，无论父实体如何

如果当前实体有任何具有 Inherited的子实体，则当您将当前实体设置为Visible?或Hidden时，它们的可见性将受到影响。

如果一个实体有父实体，但父实体缺少与可见性相关的组件，则事物的行为就像没有父实体一样。

InheritedVisibility

InheritedVisibility表示当前实体基于其父实体的可见性而具有的状态。

InheritedVisibility的值应被视为只读。它由 Bevy 内部管理，其方式类似于变换传播。一个“可见性传播”系统在时间表?PostUpdate中运行。

如果您想读取当前帧的最新值，您应该将?您的系统添加到计划?PostUpdate?中并在
?VisibilitySystems::VisibilityPropagate之后对其进行排序。

/// Check if a specific UI button is visible
/// 检查特定的UI按钮是否可见
/// (could be hidden if the whole menu is hidden?)
/// (如果整个菜单都隐藏了，也可以隐藏吗?)
fn debug_player_visibility(
    query: Query<&InheritedVisibility, With<MyAcceptButton>>,
) {
    let vis = query.single();

    debug!("Button visibility: {:?}", vis.get());
}

use bevy::render::view::VisibilitySystems;

app.add_systems(PostUpdate,
    debug_player_visibility
        .after(VisibilitySystems::VisibilityPropagate)
);

ViewVisibility

ViewVisibility代表 Bevy 做出的关于是否需要渲染该实体的实际最终决定。

ViewVisibility?的值是只读的。它由 Bevy 进行内部管理。

它用于“剔除”：如果实体不在任何Camera或Light的范围内，则不需要渲染，因此Bevy将隐藏它以提高性能。

每一帧，在“可见性传播”之后，Bevy 都会检查哪些视图（相机或灯光）可以看到哪些实体，并将结果存储在这些组件中。

如果您想读取当前帧的最新值，您应该将?您的系统添加到计划?PostUpdate中并在VisibilitySystems::CheckVisibility?之后对其进行排序。

/// Check if balloons are seen by any Camera, Light, etc… (not culled)
/// 检查气球是否被任何相机、灯光等看到…（未剔除）
fn debug_balloon_visibility(
    query: Query<&ViewVisibility, With<Balloon>>,
) {
    for vis in query.iter() {
        if vis.get() {
            debug!("Balloon will be rendered.");
        }
    }
}

use bevy::render::view::VisibilitySystems;

app.add_systems(PostUpdate,
    debug_balloon_visibility
        .after(VisibilitySystems::CheckVisibility)
);

General Graphics Features - Unofficial Bevy Cheat Book

非官方 Bevy 作弊书

6.1 相机

相机驱动 Bevy 中的所有渲染。他们负责配置绘制什么、如何绘制以及在哪里绘制。

您必须至少拥有一个相机实体，才能显示任何内容！如果您忘记生成相机，您将得到一个空的黑屏。

在最简单的情况下，您可以使用默认设置创建相机。只需使用Camera2dBundle或 Camera3dBundle生成一个实体。它将简单地绘制所有可见的可渲染实体。

本页提供了 Bevy 中相机的总体概述。另请参阅2D 相机和3D 相机的专用页面。

实用建议：始终为您的相机实体创建标记组件，以便您可以轻松查询您的相机！

#[derive(Component)]
struct MyGameCamera;

fn setup(mut commands: Commands) {
    commands.spawn((
        Camera3dBundle::default(),
        MyGameCamera,
    ));
}

相机变换

相机具有变换功能，可用于定位或旋转相机。这就是移动相机的方式。

例如，请参阅这些食谱页面：

• 3D 泛轨道相机，就像 3D 编辑器应用程序中一样

如果您正在制作游戏，您应该实现自己的自定义相机控制，使其适合您的游戏类型和游戏玩法。

变焦相机

不要使用变换比例来“缩放”相机！它只是拉伸图像，而不是“缩放”。它还可能导致其他问题和不兼容。使用投影进行缩放。

对于正交投影，请更改比例。对于透视投影，更改 FOV。FOV 模仿镜头变焦的效果。

了解有关如何在2D或?3D中执行此操作的更多信息。

投影

相机投影负责将坐标系映射到视口（通常是屏幕/窗口）。它配置坐标空间以及图像的任何缩放/拉伸。

Bevy 提供两种投影：?OrthographicProjection和?PerspectiveProjection。它们是可配置的，能够服务于各种不同的用例。

正交意味着所有物体始终显示相同的尺寸，无论距相机有多远。

透视意味着物体距离相机越远，看起来就越小。这种效果赋予 3D 图形深度感和距离感。

2D 相机始终是正交的。

3D 相机可以使用任何一种投影。透视是最常见（也是默认）的选择。正交对于 CAD 和工程等应用程序非常有用，在这些应用程序中，您希望准确表示对象的尺寸，而不是创建逼真的 3D 空间感。一些游戏（尤其是模拟游戏）使用正交文字作为艺术选择。

可以实现您自己的自定义相机投影。这可以让您完全控制坐标系。但是，请注意，如果您违反 Bevy 的坐标系约定，事情可能会以意想不到的方式运行！

HDR 和色调映射

看这里！

渲染目标

相机的渲染目标决定了 GPU 将物体绘制到的位置。它可以是一个窗口（用于直接输出到屏幕）或??Image资产（渲染到纹理）。

默认情况下，摄像机输出到主窗口。

use bevy::render::camera::RenderTarget;

fn debug_render_targets(
    q: Query<&Camera>,
) {
    for camera in &q {
        match &camera.target {
            RenderTarget::Window(wid) => {
                eprintln!("Camera renders to window with id: {:?}", wid);
            }
            RenderTarget::Image(handle) => {
                eprintln!("Camera renders to image asset with id: {:?}", handle);
            }
            RenderTarget::TextureView(_) => {
                eprintln!("This is a special camera that outputs to something outside of Bevy.");
            }
        }
    }
}

视口

视口是一种将相机限制在其渲染目标的子区域（定义为矩形）的（可选）方法。该矩形实际上被视为要绘制的“窗口”。

一个明显的用例是分屏游戏，您希望相机仅绘制到屏幕的一半。

use bevy::render::camera::Viewport;

fn setup_minimap(mut commands: Commands) {
    commands.spawn((
        Camera2dBundle {
            camera: Camera {
                // renders after / on top of other cameras
                // 渲染后/在其他相机之上
                order: 2,
                // set the viewport to a 256x256 square in the top left corner
                // 将视口设置为左上角的256x256正方形
                viewport: Some(Viewport {
                    physical_position: UVec2::new(0, 0),
                    physical_size: UVec2::new(256, 256),
                    ..default()
                }),
                ..default()
            },
            ..default()
        },
        MyMinimapCamera,
    ));
}

如果您需要找出相机渲染到的区域（视口，如果配置，或整个窗口，如果没有）：

fn debug_viewports(
    q: Query<&Camera, With<MyExtraCamera>>,
) {
    let camera = q.single();

    // the size of the area being rendered to
    // 渲染区域的大小
    let view_dimensions = camera.logical_viewport_size().unwrap();

    // the coordinates of the rectangle covered by the viewport
    // 视口覆盖的矩形的坐标
    let rect = camera.logical_viewport_rect().unwrap();
}

坐标转换

Camera提供了帮助屏幕坐标和世界空间坐标之间坐标转换的方法。有关示例，请参阅“光标到世界”食谱页面。

颜色清晰

这是在相机渲染任何内容之前整个视口将被清除的“背景颜色”。

如果您想保留所有像素之前的样子，您还可以禁用相机上的清除功能。

请参阅此页面了解更多信息。

渲染层

RenderLayers是一种过滤哪些实体应该由哪些相机绘制的方法。将此组件插入到您的实体上，将它们放置在特定的“层”中。层数是从 0 到 31 的整数（总共 32 个可用层）。

将此组件插入到相机实体上可以选择相机应渲染的图层。将此组件插入到可渲染实体上可以选择哪些相机应渲染这些实体。如果相机的图层和实体的图层之间存在任何重叠（它们至少有一个共同的图层），则将渲染实体。

如果实体没有该RenderLayers组件，则假定它（仅）属于第 0 层。

use bevy::render::view::visibility::RenderLayers;
// This camera renders everything in layers 0, 1
// 这个相机在0,1层渲染所有内容
commands.spawn((
    Camera2dBundle::default(),
    RenderLayers::from_layers(&[0, 1])
));
// This camera renders everything in layers 1, 2
// 这个相机在1、2层渲染所有内容
commands.spawn((
    Camera2dBundle::default(),
    RenderLayers::from_layers(&[1, 2])
));
// This sprite will only be seen by the first camera
// 这个精灵只会被第一个摄像头看到
commands.spawn((
    SpriteBundle::default(),
    RenderLayers::layer(0),
));
// This sprite will be seen by both cameras
// 这个精灵会被两个摄像头看到
commands.spawn((
    SpriteBundle::default(),
    RenderLayers::layer(1),
));
// This sprite will only be seen by the second camera
// 这个精灵只会被第二个摄像头看到
commands.spawn((
    SpriteBundle::default(),
    RenderLayers::layer(2),
));
// This sprite will also be seen by both cameras
// 这个精灵也会被两个摄像头看到
commands.spawn((
    SpriteBundle::default(),
    RenderLayers::from_layers(&[0, 2]),
));

您还可以在生成实体后修改它们的渲染层。

相机订购

相机order是一个简单的整数值，它控制相对于具有相同渲染目标的任何其他相机的顺序。

例如，如果您有多个摄像机全部渲染到主窗口，它们将表现为多个“层”。具有较高顺序值的相机将在具有较低值的相机“顶部”渲染。0是默认值。

use bevy::core_pipeline::clear_color::ClearColorConfig;

commands.spawn((
    Camera2dBundle {
        camera_2d: Camera2d {
            // no "background color", we need to see the main camera's output
            // 没有“背景色”，我们需要查看主摄像头的输出
            clear_color: ClearColorConfig::None,
            ..default()
        },
        camera: Camera {
            // renders after / on top of the main camera
            // 渲染后/在主摄像机顶部
            order: 1,
            ..default()
        },
        ..default()
    },
    MyOverlayCamera,
));

界面渲染

Bevy UI 渲染已集成到相机中！默认情况下，每个相机也会绘制 UI。

但是，如果您使用多个摄像头，您可能只希望 UI 绘制一次（可能由主摄像头绘制）。您可以禁用其他相机上的 UI 渲染。

此外，Bevy 中多个摄像头上的 UI 目前已损坏。即使您想要多个 UI 摄像头（例如，在具有多个窗口的应用程序中显示 UI），它也无法正常工作。

commands.spawn((
    Camera3dBundle::default(),
    // UI config is a separate component
    // UI配置是一个独立的组件
    UiCameraConfig {
        show_ui: false,
    },
    MyExtraCamera,
));

禁用相机

您可以停用相机而无需使其消失。当您想要保留相机实体及其携带的所有配置时，这非常有用，以便您以后可以轻松地重新启用它。

一些示例用例：切换覆盖、在 2D 和 3D 视图之间切换。

fn toggle_overlay(
    mut q: Query<&mut Camera, With<MyOverlayCamera>>,
) {
    let mut camera = q.single_mut();
    camera.is_active = !camera.is_active;
}

多个摄像头

这是您需要多个相机实体的不同场景的概述。

多个窗口

官方示例：multiple_windows.

如果要创建具有多个窗口的 Bevy 应用程序，则需要生成多个摄像机，每个窗口一个，并分别设置它们的渲染目标。然后，您可以使用相机来控制每个窗口中显示的内容。

分屏

官方示例：split_screen.

您可以将相机视口设置为仅渲染到渲染目标的一部分。这样，相机就可以渲染屏幕的一半（或任何其他区域）。在分屏游戏中为每个视图使用单独的摄像机。

叠加层

官方示例：two_passes.

您可能想要将多个“层”（通道）渲染到同一渲染目标。一个示例可能是显示在主游戏顶部的覆盖层/HUD。

覆盖相机可能与主相机完全不同。例如，主相机可能绘制 3D 场景，而叠加相机可能绘制 2D 形状。这样的用例是可能的！

使用单独的相机来创建叠加层。将优先级设置得?更高，以告诉 Bevy 在主摄像机之后（之上）渲染它。确保禁用清除！

考虑一下您希望哪个摄像头负责渲染 UI。如果您希望覆盖层相机不受影响，请使用覆盖层相机；如果您希望覆盖层位于 UI 之上，请使用主相机。在另一台相机上禁用它。

使用渲染层来控制每个摄像机应渲染哪些实体。

渲染到图像

（又名渲染到纹理）

官方示例：render_to_texture.

如果要在内存中生成图像，可以输出到资产Image。

这对于游戏中的中间步骤非常有用，例如在射击游戏中渲染小地图或枪。然后，您可以使用该图像作为最终场景的一部分渲染到屏幕上。项目预览是一个类似的用例。

另一个用例是想要生成图像文件的无窗口应用程序。例如，您可以使用 Bevy 渲染某些内容，然后将其导出到 PNG 文件。

非官方 Bevy 作弊书

6.2 高动态范围

HDR（高动态范围）是指游戏引擎处理非常明亮的灯光或颜色的能力。Bevy 的渲染内部是 HDR。这意味着您可以拥有颜色高于1.0、非常明亮的灯光或明亮的发射材料的物体。所有这些都支持 3D 和 2D。

不要将其与 HDR 显示输出混淆，后者是生成 HDR 图像并由具有 HDR 功能的现代显示器或电视显示的能力。Bevy 尚未对此提供支持。

内部 HDR 图像必须先转换为 SDR（标准动态范围），然后才能显示在屏幕上。这个过程称为?色调映射。Bevy 支持不同的算法，可能会产生不同的外观。在游戏中使用哪种色调映射算法是一种艺术选择。

相机HDR配置

每个摄像机都有一个切换开关，可让您决定是否希望 Bevy 在内部保留 HDR 数据，以便后续通道（例如后处理效果）可以使用它。

commands.spawn((
    Camera3dBundle {
        camera: Camera {
            hdr: true,
            ..default()
        },
        ..default()
    },
));

如果启用，Bevy 的中间纹理将采用 HDR 格式。着色器输出 HDR 值，Bevy 将存储它们，以便它们可以在以后的渲染过程中使用。这允许您启用Bloom等利用 HDR 数据的效果。在不再需要 HDR 数据后，色调映射将作为后处理步骤进行。

如果禁用，着色器将输出 0.0 到 1.0 范围内的标准 RGB 颜色。色调映射发生在着色器中。不保留 HDR 信息。需要 HDR 数据的效果（例如 Bloom）将不起作用。

默认情况下它是禁用的，因为这可以为不需要它的简单图形应用程序带来更好的性能并减少 VRAM 使用量。

如果您同时启用了 HDR 和 MSAA，则可能会遇到问题。在某些情况下可能会出现视觉伪影。它在 Web/WASM 上也不支持，运行时会崩溃。如果您遇到任何此类问题，请禁用 MSAA。

色调映射

色调映射是渲染过程的步骤，其中像素的颜色从引擎内的中间表示转换为应在屏幕上显示的最终值。

这对于 HDR 应用程序非常重要，因为在这种情况下，图像可能包含非常亮的像素（高于 1.0），需要将其重新映射到可以显示的范围。

默认情况下启用色调映射。Bevy 允许您通过 ( Tonemapping) 组件针对每个摄像机进行配置。不建议禁用它，除非您知道只有非常简单的图形不需要它。它会使您的图形看起来不正确。

use bevy::core_pipeline::tonemapping::Tonemapping;

commands.spawn((
    Camera3dBundle {
        // no tonemapping
        // 没有色调映射
        tonemapping: Tonemapping::None,
        ..default()
    },
));
commands.spawn((
    Camera3dBundle {
        // this is the default:
        // 这是默认值:
        tonemapping: Tonemapping::TonyMcMapface,
        ..default()
    },
));
commands.spawn((
    Camera3dBundle {
        // another common choice:
        // 另一个常见的选择:
        tonemapping: Tonemapping::ReinhardLuminance,
        ..default()
    },
));

Bevy 支持许多不同的色调映射算法。它们中的每一个都会产生不同的外观，影响颜色和亮度。这可以是一种艺术选择。您可以决定哪种算法最适合您的游戏。Bevy 的默认值是 TonyMcMapface，尽管名字很傻，但它为各种图形样式提供了非常好的结果。???????有关每个可用选项的说明，请参阅 (Tonemapping ) 文档。

一些色调映射算法（包括默认的 TonyMcMapface）需要?tonemapping_luts?cargo feature。默认情况下它是启用的。如果您禁用默认功能并且需要它，请务必重新启用它。启用它还可以启用ktx2和zstd功能，因为它的工作原理是将 KTX2 格式的特殊数据嵌入到游戏中，在色调映射过程中使用。

以下色调映射算法不需要来自?tonemapping_luts?的特殊数据：

• Reinhard
• ReinhardLuminance
• AcesFitted
• SomewhatBoringDisplayTransform

以下色调映射算法需要来自 ???????tonemapping_luts?的特殊数据：

• AgX
• TonyMcMapface
• BlenderFilmic

如果您想制作较小的游戏二进制文件（可能对网页游戏很重要），您可以通过将默认色调映射更改为更简单的内容并禁用?cargo features.来减少膨胀。

颜色分级

颜色分级是对图像整体外观的处理。

与色调映射一起，这会影响最终图像的“色调”/“情绪”。

这也是实现“视网膜”效果的方法，其中相机通过调整曝光/伽玛动态适应非常黑暗（例如在洞穴内）和非常明亮（例如在日光下）的场景。

您还可以调整颜色饱和度。严重降低图像的饱和度可能会导致灰度或柔和的外观，这对于世界末日或恐怖游戏来说是一个很好的艺术选择。

您可以通过???????ColorGrading?组件配置这些参数：

use bevy::render::view::ColorGrading;

commands.spawn((
    Camera3dBundle {
        color_grading: ColorGrading {
            exposure: 0.0,
            gamma: 1.0,
            pre_saturation: 1.0,
            post_saturation: 1.0,
        },
        ..default()
    },
));

解带抖动

去带抖动有助于颜色渐变或其他颜色发生细微变化的区域显得更高质量，而不会出现“色带”效果。

它默认启用，并且可以针对每个摄像机禁用。

use bevy::core_pipeline::tonemapping::DebandDither;

commands.spawn((
    Camera3dBundle {
        dither: DebandDither::Disabled,
        ..default()
    },
));

以下是不带抖动（顶部）和带抖动（底部）的示例图像。注意地平面上绿色渐变的质量/平滑度。在具有逼真图形的游戏中，类似的情况可能会出现在天空、黑暗的房间或发出光晕效果的灯光中。

非官方 Bevy 作弊书

6.3 盛开?Bloom

“绽放”效果会在明亮的灯光周围产生辉光。尽管它的灵感来自光线透过肮脏或不完美的镜头的样子，但它并不是物理上精确的效果。

Bloom 在帮助感知非常亮的光线方面做得很好，尤其是在不支持将 HDR 输出到显示硬件时。您的显示器只能显示一定的最大亮度，因此布卢姆是一种常见的艺术选择，试图传达比可显示更亮的光强度。

Bloom 使用色调映射算法看起来效果最好，该算法可以降低非常明亮的颜色的饱和度。Bevy的默认是一个不错的选择。

Bloom 需要在您的相机上启用HDR 模式。将?BloomSettings组件添加到相机以启用光晕并配置效果。

use bevy::core_pipeline::bloom::BloomSettings;

commands.spawn((
    Camera3dBundle {
        camera: Camera {
            hdr: true,
            ..default()
        },
        ..default()
    },
    BloomSettings::NATURAL,
));

绽放设置

Bevy 提供了许多参数来调整光晕效果的外观。

默认模式是“能量守恒”，这更接近真实光物理的表现。它试图模仿光散射的效果，而不人为地使图像变亮。效果更加微妙和“自然”。

还有一种“附加”模式，它会使所有东西变亮，让人感觉明亮的灯光不自然地“发光”。这种效果在许多游戏中都很常见，尤其是 2000 年代的老游戏。

Bevy 提供三种绽放“预设”：

• NATURAL：节能、微妙、自然的外观。
• OLD_SCHOOL：“发光”效果，类似于旧游戏的外观。
• SCREEN_BLUR：非常强烈的绽放，使一切看起来都很模糊。

您还可以根据自己的喜好调整???????BloomSettings的所有参数来创建完全自定义的配置。使用预设来获取灵感。

以下是 Bevy 预设的设置：

// NATURAL
// 自然
BloomSettings {
    intensity: 0.15,
    low_frequency_boost: 0.7,
    low_frequency_boost_curvature: 0.95,
    high_pass_frequency: 1.0,
    prefilter_settings: BloomPrefilterSettings {
        threshold: 0.0,
        threshold_softness: 0.0,
    },
    composite_mode: BloomCompositeMode::EnergyConserving,
};

// OLD_SCHOOL
// 老学校
BloomSettings {
    intensity: 0.05,
    low_frequency_boost: 0.7,
    low_frequency_boost_curvature: 0.95,
    high_pass_frequency: 1.0,
    prefilter_settings: BloomPrefilterSettings {
        threshold: 0.6,
        threshold_softness: 0.2,
    },
    composite_mode: BloomCompositeMode::Additive,
};

// SCREEN_BLUR
// 屏幕模糊
BloomSettings {
    intensity: 1.0,
    low_frequency_boost: 0.0,
    low_frequency_boost_curvature: 0.0,
    high_pass_frequency: 1.0 / 3.0,
    prefilter_settings: BloomPrefilterSettings {
        threshold: 0.0,
        threshold_softness: 0.0,
    },
    composite_mode: BloomCompositeMode::EnergyConserving,
};

可视化

以下是 3D Bloom 的示例：

这是一个 2D 示例：