Bevy Shader Explorer
Search across packages, versions, files, declarations, and comments. Use multiple terms to narrow results (AND), and add @vertex, @fragment, or @compute to filter by shader stage.
Packages › bevy_anti_alias › smaa.wgsl

Constants

SMAA_THRESHOLD

#
Active when
SMAA_PRESET_LOW
const SMAA_THRESHOLD: f32 = 0.15
Active when
!SMAA_PRESET_LOW
const SMAA_THRESHOLD: f32 = 0.1
Active when
!SMAA_PRESET_LOW
const SMAA_THRESHOLD: f32 = 0.1
Active when
!SMAA_PRESET_LOW
const SMAA_THRESHOLD: f32 = 0.05
Active when
!SMAA_PRESET_LOW
const SMAA_THRESHOLD: f32 = 0.1

SMAA_MAX_SEARCH_STEPS

#
Active when
SMAA_PRESET_LOW
const SMAA_MAX_SEARCH_STEPS: u32 = 4u
Active when
!SMAA_PRESET_LOW
const SMAA_MAX_SEARCH_STEPS: u32 = 8u
Active when
!SMAA_PRESET_LOW
const SMAA_MAX_SEARCH_STEPS: u32 = 16u
Active when
!SMAA_PRESET_LOW
const SMAA_MAX_SEARCH_STEPS: u32 = 32u
Active when
!SMAA_PRESET_LOW
const SMAA_MAX_SEARCH_STEPS: u32 = 16u

SMAA_MAX_SEARCH_STEPS_DIAG

#
Active when
!SMAA_PRESET_LOW
const SMAA_MAX_SEARCH_STEPS_DIAG: u32 = 8u
Active when
!SMAA_PRESET_LOW
const SMAA_MAX_SEARCH_STEPS_DIAG: u32 = 16u
Active when
!SMAA_PRESET_LOW
const SMAA_MAX_SEARCH_STEPS_DIAG: u32 = 8u

SMAA_CORNER_ROUNDING

#
Active when
!SMAA_PRESET_LOW
const SMAA_CORNER_ROUNDING: u32 = 25u
Active when
!SMAA_PRESET_LOW
const SMAA_CORNER_ROUNDING: u32 = 25u
Active when
!SMAA_PRESET_LOW
const SMAA_CORNER_ROUNDING: u32 = 25u

SMAA_LOCAL_CONTRAST_ADAPTATION_FACTOR

#
const SMAA_LOCAL_CONTRAST_ADAPTATION_FACTOR: f32 = 2.0

SMAA_AREATEX_MAX_DISTANCE

#
const SMAA_AREATEX_MAX_DISTANCE: f32 = 16.0

SMAA_AREATEX_MAX_DISTANCE_DIAG

#
const SMAA_AREATEX_MAX_DISTANCE_DIAG: f32 = 20.0

SMAA_AREATEX_PIXEL_SIZE

#
const SMAA_AREATEX_PIXEL_SIZE: vec2<f32> = (1.0 / vec2<f32>(160.0, 560.0))

SMAA_AREATEX_SUBTEX_SIZE

#
const SMAA_AREATEX_SUBTEX_SIZE: f32 = (1.0 / 7.0)

SMAA_SEARCHTEX_SIZE

#
const SMAA_SEARCHTEX_SIZE: vec2<f32> = vec2(66.0, 33.0)

SMAA_SEARCHTEX_PACKED_SIZE

#
const SMAA_SEARCHTEX_PACKED_SIZE: vec2<f32> = vec2(64.0, 16.0)

SMAA_CORNER_ROUNDING_NORM

#
Active when
!SMAA_DISABLE_CORNER_DETECTION
const SMAA_CORNER_ROUNDING_NORM: f32 = f32(SMAA_CORNER_ROUNDING) / 100.0

Bindings

color_texture

#
@group(0)
@binding(0)
var color_texture: texture_2d<f32>

smaa_info

#
@group(0)
@binding(1)
var<uniform> smaa_info: SmaaInfo

color_sampler

#
Active when
SMAA_EDGE_DETECTION
@group(1)
@binding(0)
var color_sampler: sampler

edges_texture

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION
@group(1)
@binding(0)
var edges_texture: texture_2d<f32>

edges_sampler

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION
@group(1)
@binding(1)
var edges_sampler: sampler

search_texture

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION
@group(1)
@binding(2)
var search_texture: texture_2d<f32>

area_texture

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION
@group(1)
@binding(3)
var area_texture: texture_2d<f32>

blend_texture

#
Active when
SMAA_NEIGHBORHOOD_BLENDING
@group(1)
@binding(0)
var blend_texture: texture_2d<f32>

blend_sampler

#
Active when
SMAA_NEIGHBORHOOD_BLENDING
@group(1)
@binding(1)
var blend_sampler: sampler

Structures

SmaaInfo

#
struct SmaaInfo {
rt_metrics: vec4<f32>,
}

VertexVaryings

#
struct VertexVaryings {
clip_coord: vec2<f32>,
tex_coord: vec2<f32>,
}

EdgeDetectionVaryings

#
struct EdgeDetectionVaryings {
@builtin(position)
position: vec4<f32>,
@location(0)
offset_0: vec4<f32>,
@location(1)
offset_1: vec4<f32>,
@location(2)
offset_2: vec4<f32>,
@location(3)
tex_coord: vec2<f32>,
}

BlendingWeightCalculationVaryings

#
struct BlendingWeightCalculationVaryings {
@builtin(position)
position: vec4<f32>,
@location(0)
offset_0: vec4<f32>,
@location(1)
offset_1: vec4<f32>,
@location(2)
offset_2: vec4<f32>,
@location(3)
tex_coord: vec2<f32>,
}

NeighborhoodBlendingVaryings

#
struct NeighborhoodBlendingVaryings {
@builtin(position)
position: vec4<f32>,
@location(0)
offset: vec4<f32>,
@location(1)
tex_coord: vec2<f32>,
}

Functions

calculate_vertex_varyings

#

The top-left has UV 0,0, the bottom-left has 0,2, and the top-right has 2,0. This means that the UV gets interpolated to 1,1 at the bottom-right corner of the clip-space rectangle that is at 1,-1 in clip space.

fn calculate_vertex_varyings (
vertex_index: u32
) -> VertexVaryings

edge_detection_vertex_main

#
@vertex
Processes each 3D point in a model before it's drawn
Active when
SMAA_EDGE_DETECTION

* Edge Detection Vertex Shader

fn edge_detection_vertex_main (
@builtin(vertex_index)
vertex_index: u32
) -> EdgeDetectionVaryings

blending_weight_calculation_vertex_main

#
@vertex
Processes each 3D point in a model before it's drawn
Active when
SMAA_BLENDING_WEIGHT_CALCULATION

* Blend Weight Calculation Vertex Shader

fn blending_weight_calculation_vertex_main (
@builtin(vertex_index)
vertex_index: u32
) -> BlendingWeightCalculationVaryings

neighborhood_blending_vertex_main

#
@vertex
Processes each 3D point in a model before it's drawn
Active when
SMAA_NEIGHBORHOOD_BLENDING

* Neighborhood Blending Vertex Shader

fn neighborhood_blending_vertex_main (
@builtin(vertex_index)
vertex_index: u32
) -> NeighborhoodBlendingVaryings

luma_edge_detection_fragment_main

#
@fragment
Calculates the final color of each pixel on the screen
Active when
SMAA_EDGE_DETECTION

* Luma Edge Detection

IMPORTANT NOTICE: luma edge detection requires gamma-corrected colors, and thus ‘color_texture’ should be a non-sRGB texture.

fn luma_edge_detection_fragment_main (
in: EdgeDetectionVaryings
) ->
@location(0)
vec4<f32>

decode_diag_bilinear_access_2

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION AND !SMAA_DISABLE_DIAG_DETECTION

* Allows to decode two binary values from a bilinear-filtered access.

fn decode_diag_bilinear_access_2 (
in_e: vec2<f32>
) -> vec2<f32>

decode_diag_bilinear_access_4

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION AND !SMAA_DISABLE_DIAG_DETECTION
fn decode_diag_bilinear_access_4 (
e: vec4<f32>
) -> vec4<f32>

search_diag_1

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION AND !SMAA_DISABLE_DIAG_DETECTION

* These functions allows to perform diagonal pattern searches.

fn search_diag_1 (
tex_coord: vec2<f32>,
dir: vec2<f32>,
e: ptr<function, vec2<f32>>
) -> vec2<f32>

search_diag_2

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION AND !SMAA_DISABLE_DIAG_DETECTION
fn search_diag_2 (
tex_coord: vec2<f32>,
dir: vec2<f32>,
e: ptr<function, vec2<f32>>
) -> vec2<f32>

area_diag

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION AND !SMAA_DISABLE_DIAG_DETECTION

* Similar to SMAAArea, this calculates the area corresponding to a certain diagonal distance and crossing edges ‘e’.

fn area_diag (
dist: vec2<f32>,
e: vec2<f32>,
offset: f32
) -> vec2<f32>

calculate_diag_weights

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION AND !SMAA_DISABLE_DIAG_DETECTION

* This searches for diagonal patterns and returns the corresponding weights.

fn calculate_diag_weights (
tex_coord: vec2<f32>,
e: vec2<f32>,
subsample_indices: vec4<f32>
) -> vec2<f32>

search_length

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION

* This allows to determine how much length should we add in the last step of the searches. It takes the bilinearly interpolated edge (see @PSEUDO_GATHER4), and adds 0, 1 or 2, depending on which edges and crossing edges are active.

fn search_length (
e: vec2<f32>,
offset: f32
) -> f32

search_x_left

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION

* Horizontal/vertical search functions for the 2nd pass.

fn search_x_left (
in_tex_coord: vec2<f32>,
end: f32
) -> f32

search_x_right

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION
fn search_x_right (
in_tex_coord: vec2<f32>,
end: f32
) -> f32

search_y_up

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION
fn search_y_up (
in_tex_coord: vec2<f32>,
end: f32
) -> f32

search_y_down

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION
fn search_y_down (
in_tex_coord: vec2<f32>,
end: f32
) -> f32

area

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION

* Ok, we have the distance and both crossing edges. So, what are the areas at each side of current edge?

fn area (
dist: vec2<f32>,
e1: f32,
e2: f32,
offset: f32
) -> vec2<f32>

detect_horizontal_corner_pattern

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION
fn detect_horizontal_corner_pattern (
weights: vec2<f32>,
tex_coord: vec4<f32>,
d: vec2<f32>
) -> vec2<f32>

detect_vertical_corner_pattern

#
Active when
SMAA_BLENDING_WEIGHT_CALCULATION
fn detect_vertical_corner_pattern (
weights: vec2<f32>,
tex_coord: vec4<f32>,
d: vec2<f32>
) -> vec2<f32>

blending_weight_calculation_fragment_main

#
@fragment
Calculates the final color of each pixel on the screen
Active when
SMAA_BLENDING_WEIGHT_CALCULATION
fn blending_weight_calculation_fragment_main (
in: BlendingWeightCalculationVaryings
) ->
@location(0)
vec4<f32>

neighborhood_blending_fragment_main

#
@fragment
Calculates the final color of each pixel on the screen
Active when
SMAA_NEIGHBORHOOD_BLENDING
fn neighborhood_blending_fragment_main (
in: NeighborhoodBlendingVaryings
) ->
@location(0)
vec4<f32>
Contents