非官方 Bevy 作弊书02-03

use bevy::window::PrimaryWindow;

/// We will store the world position of the mouse cursor here.
/// 我们将在此处存储鼠标光标的世界位置。
#[derive(Resource, Default)]
struct MyWorldCoords(Vec2);

/// Used to help identify our main camera
/// 用于帮助识别我们的主摄像头
#[derive(Component)]
struct MainCamera;

fn setup(mut commands: Commands) {
    // Make sure to add the marker component when you set up your camera
    // 设置相机时，请确保添加标记组件
    commands.spawn((Camera2dBundle::default(), MainCamera));
}

fn my_cursor_system(
    mut mycoords: ResMut<MyWorldCoords>,
    // query to get the window (so we can read the current cursor position)
    // 获取窗口的查询(以便我们可以读取当前光标的位置)
    q_window: Query<&Window, With<PrimaryWindow>>,
    // query to get camera transform
    // 查询以获取相机变换
    q_camera: Query<(&Camera, &GlobalTransform), With<MainCamera>>,
) {
    // get the camera info and transform
    // 获取相机信息并进行转换
    // assuming there is exactly one main camera entity, so Query::single() is OK
    // 假设只有一个主摄像机实体，那么Query::single()就可以了
    let (camera, camera_transform) = q_camera.single();

    // There is only one primary window, so we can similarly get it from the query:
    // 只有一个主窗口，所以我们可以类似地从查询中获取它:
    let window = q_window.single();

    // check if the cursor is inside the window and get its position
    // 检查光标是否在窗口内并获取它的位置
    // then, ask bevy to convert into world coordinates, and truncate to discard Z
    // 然后，让bevy转换为世界坐标，并截断以丢弃Z
    if let Some(world_position) = window.cursor_position()
        .and_then(|cursor| camera.viewport_to_world(camera_transform, cursor))
        .map(|ray| ray.origin.truncate())
    {
        mycoords.0 = world_position;
        eprintln!("World coords: {}/{}", world_position.x, world_position.y);
    }
}

app.init_resource::<MyWorldCoords>();
app.add_systems(Startup, setup);
app.add_systems(Update, my_cursor_system);

use bevy::render::camera::RenderTarget;
use bevy::window::WindowRef;

/// We will add this to each camera we want to compute cursor position for.
/// 我们将把它添加到每个我们想要计算光标位置的相机中。
/// Add the component to the camera that renders to each window.
/// 将组件添加到渲染每个窗口的相机中。
#[derive(Component, Default)]
struct WorldCursorCoords(Vec2);

fn setup_multiwindow(mut commands: Commands) {
    // TODO: set up multiple cameras for multiple windows.
    // TODO:为多个窗口设置多个摄像头。
    // See bevy's example code for how to do that.
    // 参见bevy的示例代码。

    // Make sure we add our component to each camera
    // 确保我们将组件添加到每个摄像头
    commands.spawn((Camera2dBundle::default(), WorldCursorCoords::default()));
}

fn my_cursor_system_multiwindow(
    // query to get the primary window
    // 查询以获取主窗口
    q_window_primary: Query<&Window, With<PrimaryWindow>>,
    // query to get other windows
    // 查询以获取其他窗口
    q_window: Query<&Window>,
    // query to get camera transform
    // 查询以获取相机变换
    mut q_camera: Query<(&Camera, &GlobalTransform, &mut WorldCursorCoords)>,
) {
    for (camera, camera_transform, mut worldcursor) in &mut q_camera {
        // get the window the camera is rendering to
        // 获取相机正在渲染的窗口
        let window = match camera.target {
            // the camera is rendering to the primary window
            // 摄像头正在渲染主窗口
            
            RenderTarget::Window(WindowRef::Primary) => {
                q_window_primary.single()
            },
            // the camera is rendering to some other window
            // 相机正在渲染到其他窗口
            RenderTarget::Window(WindowRef::Entity(e_window)) => {
                q_window.get(e_window).unwrap()
            },
            // the camera is rendering to something else (like a texture), not a window
            // 相机正在渲染其他东西(比如纹理)，而不是窗口
            _ => {
                // skip this camera   // 跳过这个相机
                continue;
            }
        };

        // check if the cursor is inside the window and get its position
        // 检查光标是否在窗口内并获取它的位置
        // then, ask bevy to convert into world coordinates, and truncate to discard Z
        // 然后，让bevy转换为世界坐标，并截断以丢弃Z
        if let Some(world_position) = window.cursor_position()
            .and_then(|cursor| camera.viewport_to_world(camera_transform, cursor))
            .map(|ray| ray.origin.truncate())
        {
            worldcursor.0 = world_position;
        }
    }
}

app.add_systems(Startup, setup_multiwindow);
app.add_systems(Update, my_cursor_system_multiwindow);

/// Here we will store the position of the mouse cursor on the 3D ground plane.
/// 这里我们将存储鼠标光标在3D地平面上的位置。
#[derive(Resource, Default)]
struct MyGroundCoords {
    // Global (world-space) coordinates
    // 全局(世界空间)坐标
    global: Vec3,
    // Local (relative to the ground plane) coordinates
    // 局部(相对于地平面)坐标
    local: Vec2,
}

/// Used to help identify our main camera
/// 用于识别主摄像头
#[derive(Component)]
struct MyGameCamera;

/// Used to help identify our ground plane
/// 用于识别地平面
#[derive(Component)]
struct MyGroundPlane;

fn setup_3d_scene(mut commands: Commands) {
    // Make sure to add the marker component when you set up your camera
    // 确保在设置相机时添加标记组件
    commands.spawn((
        MyGameCamera,
        Camera3dBundle {
            // ... your camera configuration ...
            / /……你的相机配置…
            ..default()
        },
    ));
    // Spawn the ground
    // 生成地面
    commands.spawn((
        MyGroundPlane,
        PbrBundle {
            // feel free to change this to rotate/tilt or reposition the ground
            // 可以随意更改它以旋转/倾斜或重新定位地面
            transform: Transform::default(),
            // TODO: set up your mesh / visuals for rendering:
            // TODO:为渲染设置网格/视觉效果:
            // mesh: ...   网格
            // material: ...    材质
            ..default()
        },
    ));
}

fn cursor_to_ground_plane(
    mut mycoords: ResMut<MyGroundCoords>,
    // query to get the window (so we can read the current cursor position)
    // 获取窗口的查询(以便我们可以读取当前光标的位置)
    // (we will only work with the primary window)
    // (我们只使用主窗口)
    q_window: Query<&Window, With<PrimaryWindow>>,
    // query to get camera transform
    // 查询以获取相机变换
    q_camera: Query<(&Camera, &GlobalTransform), With<MyGameCamera>>,
    // query to get ground plane's transform
    // 查询来获取地平面的变换
    q_plane: Query<&GlobalTransform, With<MyGroundPlane>>,
) {
    // get the camera info and transform
    // 获取相机信息并进行转换
    // assuming there is exactly one main camera entity, so Query::single() is OK
    // 假设只有一个主摄像机实体，那么Query::single()就可以了
    let (camera, camera_transform) = q_camera.single();

    // Ditto for the ground plane's transform
    // 对地平面的变换也是如此
    let ground_transform = q_plane.single();

    // There is only one primary window, so we can similarly get it from the query:
    // 只有一个主窗口，所以我们可以类似地从查询中获取它:
    let window = q_window.single();

    // check if the cursor is inside the window and get its position
    // 检查光标是否在窗口内并获取它的位置
    let Some(cursor_position) = window.cursor_position() else {
        // if the cursor is not inside the window, we can't do anything
        // 如果光标不在窗口内，我们什么也做不了
        return;
    };

    // Mathematically, we can represent the ground as an infinite flat plane.
    // 在数学上，我们可以将地面表示为一个无限平面。
    // To do that, we need a point (to position the plane) and a normal vector
    // 为此，我们需要一个点(用于放置平面)和一个法向量
    // (the "up" direction, perpendicular to the ground plane).
    // (向上，垂直于地平面)。

    // We can get the correct values from the ground entity's GlobalTransform
    // 我们可以从地面实体的GlobalTransform中获取正确的值
    let plane_origin = ground_transform.translation();
    let plane_normal = ground_transform.up();

    // Ask Bevy to give us a ray pointing from the viewport (screen) into the world
    // 让Bevy给我们一条从视口(屏幕)指向现实世界的光线
    let Some(ray) = camera.viewport_to_world(camera_transform, cursor_position) else {
        // if it was impossible to compute for whatever reason; we can't do anything
        // 如果由于某种原因无法计算;我们什么都做不了
        return;
    };

    // do a ray-plane intersection test, giving us the distance to the ground
    // 做一个射线平面相交测试，得到到地面的距离
    let Some(distance) = ray.intersect_plane(plane_origin, plane_normal) else {
        // If the ray does not intersect the ground
        // 如果光线不与地面相交
        // (the camera is not looking towards the ground), we can't do anything
        // (摄像头没有朝向地面)，我们什么都做不了
        return;
    };

    // use the distance to compute the actual point on the ground in world-space
    // 使用距离来计算现实世界中地面上的实际点
    let global_cursor = ray.get_point(distance);

    mycoords.global = global_cursor;
    eprintln!("Global cursor coords: {}/{}/{}",
        global_cursor.x, global_cursor.y, global_cursor.z
    );

    // to compute the local coordinates, we need the inverse of the plane's transform
    // 为了计算局部坐标，我们需要平面变换的逆
    let inverse_transform_matrix = ground_transform.compute_matrix().inverse();
    let local_cursor = inverse_transform_matrix.transform_point3(global_cursor);

    // we can discard the Y coordinate, because it should always be zero
    // 我们可以放弃Y坐标，因为它应该始终为0
    // (our point is supposed to be on the plane)
    // (我们的点应该在平面上)
    mycoords.local = local_cursor.xz();
    eprintln!("Local cursor coords: {}/{}", local_cursor.x, local_cursor.z);
}

app.init_resource::<MyGroundCoords>();
app.add_systems(Startup, setup_3d_scene);
app.add_systems(Update, cursor_to_ground_plane);

use bevy::core_pipeline::tonemapping::Tonemapping;
use bevy::render::primitives::Frustum;
use bevy::render::camera::{Camera, CameraProjection};
use bevy::render::view::VisibleEntities;

#[derive(Component, Debug, Clone, Reflect)]
#[reflect(Component, Default)]
struct SimpleOrthoProjection {     // 简单正交投影
    near: f32,
    far: f32,
    aspect: f32,
}

impl CameraProjection for SimpleOrthoProjection {
    fn get_projection_matrix(&self) -> Mat4 {
        Mat4::orthographic_rh(
            -self.aspect, self.aspect, -1.0, 1.0, self.near, self.far
        )
    }

    // what to do on window resize
    // 调整窗口大小时要做什么
    fn update(&mut self, width: f32, height: f32) {
        self.aspect = width / height;
    }

    fn far(&self) -> f32 {
        self.far
    }
}

impl Default for SimpleOrthoProjection {
    fn default() -> Self {
        Self { near: 0.0, far: 1000.0, aspect: 1.0 }
    }
}

fn setup(mut commands: Commands) {
    // We need all the components that Bevy's built-in camera bundles would add
    // 我们需要Bevy内置camera bundle所添加的所有组件
    // Refer to the Bevy source code to make sure you do it correctly:
    // 参考Bevy的源代码以确保正确操作:

    // here we show a 2d example
    // 这里我们展示一个2d示例

    let projection = SimpleOrthoProjection::default();

    // position the camera like bevy would do by default for 2D:
    // 像bevy在2D情况下默认做的那样定位相机:
    let transform = Transform::from_xyz(0.0, 0.0, projection.far - 0.1);

    // frustum construction code copied from Bevy
    // 从Bevy中复制截锥构造代码
    let view_projection =
        projection.get_projection_matrix() * transform.compute_matrix().inverse();
    let frustum = Frustum::from_view_projection(
        &view_projection,
        &transform.translation,
        &transform.back(),
        projection.far,
    );

    commands.spawn((
        bevy::render::camera::CameraRenderGraph::new(bevy::core_pipeline::core_2d::graph::NAME),
        projection,
        frustum,
        transform,
        GlobalTransform::default(),
        VisibleEntities::default(),
        Camera::default(),
        Camera2d::default(),
        Tonemapping::Disabled,
    ));
}

fn main() {
    // need to add bevy-internal camera projection management functionality
    // 需要添加bevy-internal相机投影管理功能
    // for our custom projection type
    // 用于自定义投影类型
    use bevy::render::camera::CameraProjectionPlugin;

    App::new()
        .add_plugins(DefaultPlugins)
        .add_startup_system(setup)
        .add_plugin(CameraProjectionPlugin::<SimpleOrthoProjection>::default())
        .run();
}

/// Tags an entity as capable of panning and orbiting.
/// 标记一个实体为可平移和绕轨道移动。
#[derive(Component)]
struct PanOrbitCamera {
    /// The "focus point" to orbit around. It is automatically updated when panning the camera
    /// 要环绕的“焦点”。当平移相机时，它会自动更新
    pub focus: Vec3,
    pub radius: f32,
    pub upside_down: bool,
}

impl Default for PanOrbitCamera {
    fn default() -> Self {
        PanOrbitCamera {
            focus: Vec3::ZERO,     // 焦点
            radius: 5.0,           // 半径
            upside_down: false,
        }
    }
}

/// Pan the camera with middle mouse click, zoom with scroll wheel, orbit with right mouse click.
/// 用鼠标中键平移相机，用滚动轮缩放，用鼠标右键绕轨道旋转。
fn pan_orbit_camera(
    windows: Res<Windows>,
    mut ev_motion: EventReader<MouseMotion>,
    mut ev_scroll: EventReader<MouseWheel>,
    input_mouse: Res<Input<MouseButton>>,
    mut query: Query<(&mut PanOrbitCamera, &mut Transform, &Projection)>,
) {
    // change input mapping for orbit and panning here
    // 在这里更改轨道和平移的输入映射
    let orbit_button = MouseButton::Right;
    let pan_button = MouseButton::Middle;

    let mut pan = Vec2::ZERO;
    let mut rotation_move = Vec2::ZERO;
    let mut scroll = 0.0;
    let mut orbit_button_changed = false;

    if input_mouse.pressed(orbit_button) {
        for ev in ev_motion.iter() {
            rotation_move += ev.delta;
        }
    } else if input_mouse.pressed(pan_button) {
        // Pan only if we're not rotating at the moment
        // 仅在当前不旋转时进行平移
        for ev in ev_motion.iter() {
            pan += ev.delta;
        }
    }
    for ev in ev_scroll.iter() {
        scroll += ev.y;
    }
    if input_mouse.just_released(orbit_button) || input_mouse.just_pressed(orbit_button) {
        orbit_button_changed = true;
    }

    for (mut pan_orbit, mut transform, projection) in query.iter_mut() {
        if orbit_button_changed {
            // only check for upside down when orbiting started or ended this frame
            // 只在轨道开始或结束时检查是否颠倒
            // if the camera is "upside" down, panning horizontally would be inverted, so invert the input to make it correct
            // 如果相机是“倒过来”的，水平平移将是反向的，因此反转输入以使其正确
            let up = transform.rotation * Vec3::Y;
            pan_orbit.upside_down = up.y <= 0.0;
        }

        let mut any = false;
        if rotation_move.length_squared() > 0.0 {
            any = true;
            let window = get_primary_window_size(&windows);
            let delta_x = {
                let delta = rotation_move.x / window.x * std::f32::consts::PI * 2.0;
                if pan_orbit.upside_down { -delta } else { delta }
            };
            let delta_y = rotation_move.y / window.y * std::f32::consts::PI;
            let yaw = Quat::from_rotation_y(-delta_x);
            let pitch = Quat::from_rotation_x(-delta_y);
            transform.rotation = yaw * transform.rotation; 
                // rotate around global y axis
                //围绕全局y轴旋转
            transform.rotation = transform.rotation * pitch; 
                // rotate around local x axis
                // 围绕局部x轴旋转
        } else if pan.length_squared() > 0.0 {
            any = true;
            // make panning distance independent of resolution and FOV,
            // 使平移距离不依赖于分辨率和视野，
            let window = get_primary_window_size(&windows);
            if let Projection::Perspective(projection) = projection {
                pan *= Vec2::new(projection.fov * projection.aspect_ratio, projection.fov) / window;
            }
            // translate by local axes
            // 通过局部轴进行平移
            let right = transform.rotation * Vec3::X * -pan.x;
            let up = transform.rotation * Vec3::Y * pan.y;
            // make panning proportional to distance away from focus point
            // 使平移与距焦点的距离成比例
            let translation = (right + up) * pan_orbit.radius;
            pan_orbit.focus += translation;
        } else if scroll.abs() > 0.0 {
            any = true;
            pan_orbit.radius -= scroll * pan_orbit.radius * 0.2;
            // dont allow zoom to reach zero or you get stuck
            // 不要让缩放达到0，否则你会卡住 
            pan_orbit.radius = f32::max(pan_orbit.radius, 0.05);
        }

        if any {
            // emulating parent/child to make the yaw/y-axis rotation behave like a turntable
            // 模拟父/子元素，使偏航/y轴旋转像转盘一样
            // parent = x and y rotation
            // parent = x和y旋转
            // child = z-offset
            // child = z-offset
            let rot_matrix = Mat3::from_quat(transform.rotation);
            transform.translation = pan_orbit.focus + rot_matrix.mul_vec3(Vec3::new(0.0, 0.0, pan_orbit.radius));
        }
    }

    // consume any remaining events, so they don't pile up if we don't need them
    // 消耗所有剩余的事件，这样如果我们不需要它们，它们就不会堆积起来
    // (and also to avoid Bevy warning us about not checking events every frame update)
    // (同时也避免了Bevy警告我们在每一帧更新时不去检查事件)
    ev_motion.clear();
}

fn get_primary_window_size(windows: &Res<Windows>) -> Vec2 {
    let window = windows.get_primary().unwrap();
    let window = Vec2::new(window.width() as f32, window.height() as f32);
    window
}

/// Spawn a camera like this
/// 像这样生成一个相机
fn spawn_camera(mut commands: Commands) {
    let translation = Vec3::new(-2.0, 2.5, 5.0);
    let radius = translation.length();

    commands.spawn((
        Camera3dBundle {
            transform: Transform::from_translation(translation)
                .looking_at(Vec3::ZERO, Vec3::Y),
            ..Default::default()
        },
        PanOrbitCamera {
            radius,
            ..Default::default()
        },
    ));
}

fn print_resources(world: &World) {
    let components = world.components();

    let mut r: Vec<_> = world
        .storages()
        .resources
        .iter()
        .map(|(id, _)| components.get_info(id).unwrap())
        .map(|info| info.name())
        .collect();

    // sort list alphebetically
    // 按字母顺序排序列表
    r.sort();
    r.iter().for_each(|name| println!("{}", name));
}

// print main world resources
// 打印主要世界资源
app.add_systems(Last, print_resources);

// print render world resources
// 打印渲染世界资源
app.sub_app_mut(RenderApp)
    .add_systems(Render, print_resources.in_set(RenderSet::Render));

非官方 Bevy 作弊书

3 bevy设置技巧

本章收集了有关配置项目或开发工具的其他技巧，这些技巧是从 Bevy 社区收集的，超出了 Bevy官方设置文档中涵盖的内容。

请随意建议本章下添加的内容。

另请参阅本书中的以下其他相关内容：

• 平台特定信息
• 用于修复性能缓慢的配置

[package]
name = "my_game"
version = "0.1.0"
edition = "2021"

[dependencies]
bevy = "0.12"

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .run();
}