raea/post_process

These are Bevy's post-processing passes, placed beside the camera: <ToneMapping>, <Bloom>, <DepthOfField>, <MotionBlur>, <AntiAliasing>, lens distortion and fisheye, plus raea's <Grade> for colour grading, <Outline> and <Look>, which sets a whole finish at once. <FramePass> and <Compute> run your own shaders on the frame.

import { Camera3d } from "raea/camera";
import { Bloom, ToneMapping } from "raea/post_process";
import { Transform } from "raea/transform";

const Glow = () => (
  <>
    <Camera3d transform={Transform.fromXyz(-2, 2.5, 5).lookingAt([0, 0, 0])} />
    <ToneMapping mode="tony" />
    <Bloom intensity={1} threshold={0} />
  </>
);

import { AntiAliasing, Bloom, Compute, DepthOfField } from "raea/post_process"

raea/post_process exports 12 components, 14 types. Bevy's counterpart: bevy_post_process, bevy_anti_alias. Source: sdk/raea/src/post_process.ts.

#Components

#AntiAliasing

How the 3D's edges are smoothed. Put it inside the Canvas3D, once; the first frame's holds for the piece.

Bevy: bevy_anti_alias::smaa::Smaa, bevy_anti_alias::fxaa::Fxaa.

Takes AntiAliasingProps's props.

#Bloom

Glow around bright parts (emissive materials, strong highlights). Put it inside the Canvas3D.

Bevy: bevy_post_process::bloom::settings::Bloom.

Takes BloomProps's props.

#Compute

A compute over the frame, in the 3D beside the camera; several run in the order written, before the cameras draw.

Rust: raea_sys_compute::Computes.

Takes ComputeProps's props.

#DepthOfField

A lens's depth of field: what's nearer or farther than the camera's focus blurs. Put it inside the Canvas3D; pull focus by animating the camera's focus. Inside a Camera3d it is Bevy's component on the camera, its focal_distance the camera's focus.

Bevy: bevy_post_process::dof::DepthOfField.

Takes DepthOfFieldProps's props.

#Fisheye

A fisheye lens on the camera: a pass over the 3D after tone mapping (the page over it stays straight). Every value animates per frame; a lens's vignette and colour fringes are 's. Put it inside the Canvas3D.

Takes FisheyeProps's props.

#FramePass

A full-screen pass over the scene camera's frame, beside the camera; several run in the order written. With a frame they run on its cells, before the look's composite.

Rust: raea_sys_framepass::FramePasses.

Takes FramePassProps's props.

#Grade

The camera's colour grade (lift, gamma, gain and saturation per range of light, before tone mapping), a lens vignette and colour fringes: one grade over every scene, so a film looks of a piece. Put it inside the Canvas3D.

Bevy: bevy_render::view::ColorGrading, bevy_post_process::effect_stack::chromatic_aberration::ChromaticAberration, bevy_post_process::effect_stack::vignette::Vignette.

Takes GradeProps's props.

#LensDistortion

Barrel or pincushion distortion (Brown-Conrady k1, k2) on the camera, a pass after tone mapping as Fisheye's. Put it inside the Canvas3D.

Bevy: bevy_post_process::LensDistortion.

Takes LensDistortionProps's props.

#Look

The whole frame drawn as a model's look draws its model: every part of the scene in the one grain, its bloom, fog and blur inside it. Put it inside the Canvas3D. mode="paint" or "cartoon" draws every standard material as paint (engine/render paint.rs):

Bevy: bevy_pbr::mesh_material::MeshMaterial3d<bevy_pbr::extended_material::ExtendedMaterial<bevy_pbr::pbr_material::StandardMaterial, raea_render::engine::paint::Paint>>.

Takes LookProps's props.

#MotionBlur

Motion blur from each part's and the camera's motion over the frame before (Bevy's MotionBlur): with it, each frame is drawn after the one before it, so a frame's blur is the same in a render, a seek and play. A frame without it has none. Put it inside the Canvas3D.

Bevy: bevy_post_process::motion_blur::MotionBlur.

Takes MotionBlurProps's props.

#Outline

Ink lines where the scene's depth steps or its surfaces turn, drawn before bloom and tone mapping; under a a cell wide (Return of the Obra Dinn's line). Put it inside the Canvas3D.

Takes OutlineProps's props.

#ToneMapping

The camera's tone mapping and exposure. Put it inside the Canvas3D.

Bevy: bevy_render::view::Tonemapping, bevy_camera::camera::Exposure.

Takes ToneMappingProps's props.

#Types

#AntiAliasingProps

#BloomProps

#ComputeProps

A compute shader (raea-sys-compute). Its source has one @compute entry point and reads time() (seconds), u_NAME() for each uniform, each buffer as NAME: array<f32> (read and written) and each image as NAME: texture_storage_2d<rgba8unorm, write>.

#DepthOfFieldProps

#FisheyeProps

#FramePassProps

A shader over the whole frame. Its source defines fn shade(in: FullscreenVertexOutput) -> vec4 (or its own

#GradeProps

#GradeSection

#LensCommon

#LensDistortionProps

#LookProps

#MotionBlurProps

#OutlineProps

#ToneMappingProps