mirror of
https://github.com/bevyengine/bevy
synced 2024-11-22 12:43:34 +00:00
20c6bcdba4
Currently, volumetric fog is global and affects the entire scene uniformly. This is inadequate for many use cases, such as local smoke effects. To address this problem, this commit introduces *fog volumes*, which are axis-aligned bounding boxes (AABBs) that specify fog parameters inside their boundaries. Such volumes can also specify a *density texture*, a 3D texture of voxels that specifies the density of the fog at each point. To create a fog volume, add a `FogVolume` component to an entity (which is included in the new `FogVolumeBundle` convenience bundle). Like light probes, a fog volume is conceptually a 1×1×1 cube centered on the origin; a transform can be used to position and resize this region. Many of the fields on the existing `VolumetricFogSettings` have migrated to the new `FogVolume` component. `VolumetricFogSettings` on a camera is still needed to enable volumetric fog. However, by itself `VolumetricFogSettings` is no longer sufficient to enable volumetric fog; a `FogVolume` must be present. Applications that wish to retain the old global fog behavior can simply surround the scene with a large fog volume. By way of implementation, this commit converts the volumetric fog shader from a full-screen shader to one applied to a mesh. The strategy is different depending on whether the camera is inside or outside the fog volume. If the camera is inside the fog volume, the mesh is simply a plane scaled to the viewport, effectively falling back to a full-screen pass. If the camera is outside the fog volume, the mesh is a cube transformed to coincide with the boundaries of the fog volume's AABB. Importantly, in the latter case, only the front faces of the cuboid are rendered. Instead of treating the boundaries of the fog as a sphere centered on the camera position, as we did prior to this patch, we raytrace the far planes of the AABB to determine the portion of each ray contained within the fog volume. We then raymarch in shadow map space as usual. If a density texture is present, we modulate the fixed density value with the trilinearly-interpolated value from that texture. Furthermore, this patch introduces optional jitter to fog volumes, intended for use with TAA. This modifies the position of the ray from frame to frame using interleaved gradient noise, in order to reduce aliasing artifacts. Many implementations of volumetric fog in games use this technique. Note that this patch makes no attempt to write a motion vector; this is because when a view ray intersects multiple voxels there's no single direction of motion. Consequently, fog volumes can have ghosting artifacts, but because fog is "ghostly" by its nature, these artifacts are less objectionable than they would be for opaque objects. A new example, `fog_volumes`, has been added. It demonstrates a single fog volume containing a voxelized representation of the Stanford bunny. The existing `volumetric_fog` example has been updated to use the new local volumetrics API. ## Changelog ### Added * Local `FogVolume`s are now supported, to localize fog to specific regions. They can optionally have 3D density voxel textures for precise control over the distribution of the fog. ### Changed * `VolumetricFogSettings` on a camera no longer enables volumetric fog; instead, it simply enables the processing of `FogVolume`s within the scene. ## Migration Guide * A `FogVolume` is now necessary in order to enable volumetric fog, in addition to `VolumetricFogSettings` on the camera. Existing uses of volumetric fog can be migrated by placing a large `FogVolume` surrounding the scene. --------- Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com> Co-authored-by: François Mockers <mockersf@gmail.com>
89 lines
2.9 KiB
Rust
89 lines
2.9 KiB
Rust
//! Demonstrates fog volumes with voxel density textures.
|
|
//!
|
|
//! We render the Stanford bunny as a fog volume. Parts of the bunny become
|
|
//! lighter and darker as the camera rotates. This is physically-accurate
|
|
//! behavior that results from the scattering and absorption of the directional
|
|
//! light.
|
|
|
|
use bevy::{
|
|
math::vec3,
|
|
pbr::{FogVolume, VolumetricFogSettings, VolumetricLight},
|
|
prelude::*,
|
|
};
|
|
|
|
/// Entry point.
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins(DefaultPlugins.set(WindowPlugin {
|
|
primary_window: Some(Window {
|
|
title: "Bevy Fog Volumes Example".into(),
|
|
..default()
|
|
}),
|
|
..default()
|
|
}))
|
|
.insert_resource(AmbientLight::NONE)
|
|
.add_systems(Startup, setup)
|
|
.add_systems(Update, rotate_camera)
|
|
.run();
|
|
}
|
|
|
|
/// Spawns all the objects in the scene.
|
|
fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
|
|
// Spawn a fog volume with a voxelized version of the Stanford bunny.
|
|
commands
|
|
.spawn(SpatialBundle {
|
|
visibility: Visibility::Visible,
|
|
transform: Transform::from_xyz(0.0, 0.5, 0.0),
|
|
..default()
|
|
})
|
|
.insert(FogVolume {
|
|
density_texture: Some(asset_server.load("volumes/bunny.ktx2")),
|
|
density_factor: 1.0,
|
|
// Scatter as much of the light as possible, to brighten the bunny
|
|
// up.
|
|
scattering: 1.0,
|
|
..default()
|
|
});
|
|
|
|
// Spawn a bright directional light that illuminates the fog well.
|
|
commands
|
|
.spawn(DirectionalLightBundle {
|
|
transform: Transform::from_xyz(1.0, 1.0, -0.3).looking_at(vec3(0.0, 0.5, 0.0), Vec3::Y),
|
|
directional_light: DirectionalLight {
|
|
shadows_enabled: true,
|
|
illuminance: 32000.0,
|
|
..default()
|
|
},
|
|
..default()
|
|
})
|
|
// Make sure to add this for the light to interact with the fog.
|
|
.insert(VolumetricLight);
|
|
|
|
// Spawn a camera.
|
|
commands
|
|
.spawn(Camera3dBundle {
|
|
transform: Transform::from_xyz(-0.75, 1.0, 2.0)
|
|
.looking_at(vec3(0.0, 0.0, 0.0), Vec3::Y),
|
|
camera: Camera {
|
|
hdr: true,
|
|
..default()
|
|
},
|
|
..default()
|
|
})
|
|
.insert(VolumetricFogSettings {
|
|
// Make this relatively high in order to increase the fog quality.
|
|
step_count: 64,
|
|
// Disable ambient light.
|
|
ambient_intensity: 0.0,
|
|
..default()
|
|
});
|
|
}
|
|
|
|
/// Rotates the camera a bit every frame.
|
|
fn rotate_camera(mut cameras: Query<&mut Transform, With<Camera3d>>) {
|
|
for mut camera_transform in cameras.iter_mut() {
|
|
*camera_transform =
|
|
Transform::from_translation(Quat::from_rotation_y(0.01) * camera_transform.translation)
|
|
.looking_at(vec3(0.0, 0.5, 0.0), Vec3::Y);
|
|
}
|
|
}
|