bevy-camera-systems
Bevy ECS skill for cameras. Keywords: Bevy, Camera, Camera2d, Camera3d, Transform.
thedivergentai · 已有静态检查记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add thedivergentai/Game-Dev-Agentic-Skills --skill bevy-camera-systems技能说明
name: bevy-camera-systems description: "Bevy ECS skill for cameras. Keywords: Bevy, Camera, Camera2d, Camera3d, Transform."
Bevy camera systems
When to use
Load this when a view must render 2D or 3D. Camera, Camera2d, Camera3d, and the two_passes example are the sources for the names below. The library pin is 0.20.
ECS shape
- Components:
Camerais the viewpoint (projection and render target). ACamerawith no render graph errors at runtime.Camera2denables the 2D graph and requiresCamera,Projection, andFrustum.Camera3denables the main 3D graph and requiresCameraandProjection. 3D space is right-handed: X right, Y up, Z back, so forward is -Z. - Spawn: the example uses
commands.spawn((Camera3d::default(), Transform::from_xyz(...).looking_at(Vec3::ZERO, Vec3::Y))). A second camera setsCamera { order: 1, clear_color: ClearColorConfig::None, ..default() }so it draws on top without clearing. - Query: systems may take
(&Camera, &GlobalTransform)withWith<Camera2d>.Camera::viewport_to_world_2dmaps a viewport position to a 2D world position for an orthographic camera along Z. - Schedule: spawn on
Startup. Follow, split viewports, and trauma offset are your components onUpdate.
fn spawn_cameras(mut commands: Commands) {
commands.spawn((
Camera3d::default(),
Transform::from_xyz(0.0, 6.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
));
commands.spawn((
Camera2d,
Camera {
order: 1,
clear_color: ClearColorConfig::None,
..default()
},
));
}
#[derive(Component)]
struct FollowTarget;
#[derive(Component)]
struct FollowCam {
offset: Vec3,
stiffness: f32,
}
fn follow_target(
time: Res<Time>,
targets: Query<&Transform, (With<FollowTarget>, Without<FollowCam>)>,
mut cameras: Query<(&FollowCam, &mut Transform)>,
) {
let Ok(target) = targets.single() else {
return;
};
let dt = time.delta_secs();
for (follow, mut transform) in &mut cameras {
let desired = target.translation + follow.offset;
let t = 1.0 - (-follow.stiffness * dt).exp();
transform.translation = transform.translation.lerp(desired, t);
transform.look_at(target.translation, Vec3::Y);
}
}
use bevy::camera::Viewport;
fn split_view(mut cameras: Query<&mut Camera, With<Camera3d>>) {
let mut iter = cameras.iter_mut();
if let Some(mut left) = iter.next() {
left.viewport = Some(Viewport {
physical_position: UVec2::new(0, 0),
physical_size: UVec2::new(640, 720),
depth: 0.0..1.0,
});
}
if let Some(mut right) = iter.next() {
right.order = 0;
right.viewport = Some(Viewport {
physical_position: UVec2::new(640, 0),
physical_size: UVec2::new(640, 720),
depth: 0.0..1.0,
});
}
}
fn cursor_to_world(
windows: Query<&Window>,
cameras: Query<(&Camera, &GlobalTransform), With<Camera2d>>,
) {
let Ok(window) = windows.single() else {
return;
};
let Ok((camera, transform)) = cameras.single() else {
return;
};
let Some(cursor) = window.cursor_position() else {
return;
};
let _world = camera.viewport_to_world_2d(transform, cursor);
}
#[derive(Component)]
struct Trauma(f32);
fn apply_trauma(time: Res<Time>, mut cameras: Query<(&mut Trauma, &mut Transform), With<Camera3d>>) {
for (mut trauma, mut transform) in &mut cameras {
trauma.0 = (trauma.0 - time.delta_secs()).max(0.0);
let shake = trauma.0 * trauma.0;
transform.translation.x += (time.elapsed_secs() * 31.0).sin() * 0.15 * shake;
transform.translation.y += (time.elapsed_secs() * 27.0).cos() * 0.1 * shake;
}
}
[dependencies]
bevy = "0.20"
View choices
| Need | Bevy approach |
|---|---|
| Active view | An entity with Camera2d or Camera3d |
| Camera pose | Transform on that entity |
| Draw order / overlay | Camera.order and ClearColorConfig::None |
| Screen point to 2D world | viewport_to_world_2d with GlobalTransform |
Scope
- Follow, look-at, trauma offset, and split
Viewports are the systems above. ACamerastill needs its render graph: spawnCamera2dorCamera3dso Bevy insertsCameraRenderGraph. - A texture target is a
RenderTarget::Imagecomponent on the camera entity. The split example keeps the window target and setsCamera::viewport.
Expert Knowledge Delta
Target: Bevy 0.20+.
Core ECS types: Component, Resource, Query, Commands, Startup, Update, Fixed / FixedMain (bevy::time), .chain(), Plugin, DefaultPlugins, MinimalPlugins. Messages and observers are an ownership slot. See bevy-events-messaging for their APIs. Systems run in parallel unless .chain() orders the ones that conflict.
Who owns state
| Piece | Owner | Who may mutate | Schedule |
|---|---|---|---|
| Data on one entity | Component | One system via Query | Update or FixedMain |
| One value for the whole app | Resource | One system | Startup to insert, then the schedule that reads it |
| Spawn | Commands | The spawning system | Startup for the initial world; later schedules for runtime spawn |
| Order that must not race | .chain() | The chained systems only | Same schedule |
| Plugin boundary | Plugin | build registers systems and resources | Before the app runs |
Borrow rule: two systems that both mutably query the same component must be ordered (.chain()) or split so only one writes. Unrelated systems stay parallel. That is the ECS page rule, not a guess at a system-set API.
Decision
| If you need | Do this | Do not |
|---|---|---|
| Per-entity data | Component + Query | A script field copied onto the entity |
| App-wide config or clock | Resource | Copy the value onto |