Enum bevy_hikari::Upscale

pub enum Upscale {
    Fsr1 {
        ratio: f32,
        sharpness: f32,
    },
    SmaaTu4x {
        ratio: f32,
    },
    None,
}

Upscale method to use.

Variants

Fsr1

Fields

ratio: f32

Renders the main pass and post process on a low resolution texture.

sharpness: f32

From 0.0 - 2.0 where 0.0 means max sharpness.

AMD FidelityFX™ Super Resolution.

SmaaTu4x

Fields

ratio: f32

Renders the main pass and post process on a low resolution texture.

Filmic SMAA TU4x.

None

Implementations

impl Upscale

pub fn ratio(&self) -> f32

Examples found in repository

src/post_process.rs (line 524)

    fn extract_component((camera, settings): QueryItem<Self::Query>) -> Self {
        let size = camera.physical_target_size().unwrap_or_default();
        let scale = settings.upscale.ratio().recip();
        let scaled_size = (scale * size.as_vec2()).ceil();
        Self {
            input_viewport_in_pixels: scaled_size,
            input_size_in_pixels: scaled_size,
            output_size_in_pixels: size.as_vec2(),
            sharpness: settings.upscale.sharpness(),
            hdr: 0,
        }
    }
}

// NOTE! Don't delete, might be used soon, instead of calulating this on GPU
// fn get_fsr_constants(ratio: f32, hdr_rcas: bool, camera: &ExtractedCamera) -> FSRConstantsUniform {
//     let mut fsr_constant = FSRConstantsUniform::default();
//     let size = camera.physical_target_size.unwrap();
//     let size_x = size.x as f32;
//     let size_y = size.x as f32;
//     compute_fsr_constants(
//         &mut fsr_constant.const_0,
//         &mut fsr_constant.const_1,
//         &mut fsr_constant.const_2,
//         &mut fsr_constant.const_3,
//         size_x,
//         size_y,
//         size_x,
//         size_y,
//         size_x * ratio,
//         size_y * ratio,
//     );

//     fsr_constant.sample.x = if hdr_rcas { 1 } else { 0 };
//     fsr_constant
// }

// pub union U32F32Union {
//     pub u: u32,
//     pub f: f32,
// }

// fn f32_u32(a: f32) -> u32 {
//     let uf = U32F32Union { f: a };
//     unsafe { uf.u }
// }

// fn compute_fsr_constants(
//     con0: &mut UVec4,
//     con1: &mut UVec4,
//     con2: &mut UVec4,
//     con3: &mut UVec4,
//     // This the rendered image resolution being upscaled
//     input_viewport_in_pixels_x: f32,
//     input_viewport_in_pixels_y: f32,
//     // This is the resolution of the resource containing the input image (useful for dynamic resolution)
//     input_size_in_pixels_x: f32,
//     input_size_in_pixels_y: f32,
//     // This is the display resolution which the input image gets upscaled to
//     output_size_in_pixels_x: f32,
//     output_size_in_pixels_y: f32,
// ) {
//     // Output integer position to a pixel position in viewport.
//     con0[0] = f32_u32(input_viewport_in_pixels_x * (1.0 / output_size_in_pixels_x));
//     con0[1] = f32_u32(input_viewport_in_pixels_y * (1.0 / output_size_in_pixels_y));
//     con0[2] = f32_u32(0.5 * input_viewport_in_pixels_x * (1.0 / output_size_in_pixels_x) - 0.5);
//     con0[3] = f32_u32(0.5 * input_viewport_in_pixels_y * (1.0 / output_size_in_pixels_y) - 0.5);

//     // Viewport pixel position to normalized image space.
//     // This is used to get upper-left of 'F' tap.
//     con1[0] = (1.0 / input_size_in_pixels_x) as u32;
//     con1[1] = (1.0 / input_size_in_pixels_y) as u32;
//     // Centers of gather4, first offset from upper-left of 'F'.
//     //      +---+---+
//     //      |   |   |
//     //      +--(0)--+
//     //      | b | c |
//     //  +---F---+---+---+
//     //  | e | f | g | h |
//     //  +--(1)--+--(2)--+
//     //  | i | j | k | l |
//     //  +---+---+---+---+
//     //      | n | o |
//     //      +--(3)--+
//     //      |   |   |
//     //      +---+---+
//     con1[2] = f32_u32(1.0 * (1.0 / input_size_in_pixels_x));
//     con1[3] = f32_u32(-1.0 * (1.0 / input_size_in_pixels_y));
//     // These are from (0) instead of 'F'.
//     con2[0] = f32_u32(-1.0 * (1.0 / input_size_in_pixels_x));
//     con2[1] = f32_u32(2.0 * (1.0 / input_size_in_pixels_y));
//     con2[2] = f32_u32(1.0 * (1.0 / input_size_in_pixels_x));
//     con2[3] = f32_u32(2.0 * (1.0 / input_size_in_pixels_y));
//     con3[0] = f32_u32(0.0 * (1.0 / input_size_in_pixels_x));
//     con3[1] = f32_u32(4.0 * (1.0 / input_size_in_pixels_y));
//     con3[2] = 0;
//     con3[3] = 0;
// }

#[derive(Component)]
pub struct PostProcessTextures {
    pub head: usize,
    pub nearest_sampler: Sampler,
    pub linear_sampler: Sampler,
    pub fallback: TextureView,
    pub denoise_internal: [TextureView; 4],
    pub denoise_internal_variance: TextureView,
    pub denoise_render: [TextureView; 3],
    pub tone_mapping_output: [TextureView; 2],
    pub taa_output: [TextureView; 2],
    pub upscale_output: [TextureView; 2],
}

fn prepare_post_process_textures(
    mut commands: Commands,
    render_device: Res<RenderDevice>,
    mut texture_cache: ResMut<TextureCache>,
    cameras: Query<(Entity, &ExtractedCamera, &FrameCounter, &HikariSettings)>,
) {
    let texture_usage = TextureUsages::TEXTURE_BINDING | TextureUsages::STORAGE_BINDING;
    let fallback = texture_cache
        .get(
            &render_device,
            TextureDescriptor {
                label: None,
                size: Extent3d {
                    width: 1,
                    height: 1,
                    depth_or_array_layers: 1,
                },
                mip_level_count: 1,
                sample_count: 1,
                dimension: TextureDimension::D2,
                format: HDR_TEXTURE_FORMAT,
                usage: texture_usage,
            },
        )
        .default_view;

    for (entity, camera, counter, settings) in &cameras {
        if let Some(size) = camera.physical_target_size {
            let mut create_texture = |texture_format, scale: f32| {
                let extent = Extent3d {
                    width: (size.x as f32 * scale).ceil() as u32,
                    height: (size.y as f32 * scale).ceil() as u32,
                    depth_or_array_layers: 1,
                };
                texture_cache
                    .get(
                        &render_device,
                        TextureDescriptor {
                            label: None,
                            size: extent,
                            mip_level_count: 1,
                            sample_count: 1,
                            dimension: TextureDimension::D2,
                            format: texture_format,
                            usage: texture_usage,
                        },
                    )
                    .default_view
            };

            macro_rules! create_texture_array {
                [$texture_format:ident, $scale:ident; $count:literal] => {
                    [(); $count].map(|_| create_texture($texture_format, $scale))
                };
                [$texture_format:ident, $scale:literal; $count:literal] => {
                    [(); $count].map(|_| create_texture($texture_format, $scale))
                };
                [$texture:ident; $count:literal] => {
                    [(); $count].map(|_| $texture.clone())
                };
            }

            let nearest_sampler = render_device.create_sampler(&SamplerDescriptor {
                mag_filter: FilterMode::Nearest,
                min_filter: FilterMode::Nearest,
                mipmap_filter: FilterMode::Nearest,
                ..Default::default()
            });
            let linear_sampler = render_device.create_sampler(&SamplerDescriptor {
                mag_filter: FilterMode::Linear,
                min_filter: FilterMode::Linear,
                mipmap_filter: FilterMode::Linear,
                ..Default::default()
            });

            let mut scale = settings.upscale.ratio().recip();

            let denoise_internal_variance = create_texture(VARIANCE_TEXTURE_FORMAT, scale);
            let denoise_internal = create_texture_array![HDR_TEXTURE_FORMAT, scale; 4];
            let denoise_render = create_texture_array![HDR_TEXTURE_FORMAT, scale; 3];

            let tone_mapping_output = create_texture_array![HDR_TEXTURE_FORMAT, scale; 2];

            let upscale_output = match settings.upscale {
                Upscale::SmaaTu4x { .. } => {
                    scale *= 2.0;
                    create_texture_array![HDR_TEXTURE_FORMAT, scale; 2]
                }
                Upscale::Fsr1 { .. } => create_texture_array![HDR_TEXTURE_FORMAT, 1.0; 2],
                Upscale::None => create_texture_array![fallback; 2],
            };

            let taa_output = match settings.taa {
                Taa::Jasmine => {
                    create_texture_array![HDR_TEXTURE_FORMAT, scale; 2]
                }
                Taa::None => create_texture_array![fallback; 2],
            };

            commands.entity(entity).insert(PostProcessTextures {
                head: counter.0 % 2,
                nearest_sampler,
                linear_sampler,
                fallback: fallback.clone(),
                denoise_internal,
                denoise_internal_variance,
                denoise_render,
                tone_mapping_output,
                taa_output,
                upscale_output,
            });
        }
    }
}

#[allow(dead_code)]
#[derive(Resource)]
pub struct CachedPostProcessPipelines {
    demodulation: CachedComputePipelineId,
    denoise_direct: [CachedComputePipelineId; 4],
    denoise: [CachedComputePipelineId; 4],
    tone_mapping: CachedComputePipelineId,
    taa_jasmine: CachedComputePipelineId,
    smaa_tu4x: CachedComputePipelineId,
    smaa_tu4x_extrapolate: CachedComputePipelineId,
    upscale: CachedComputePipelineId,
    upscale_sharpen: CachedComputePipelineId,
}

fn queue_post_process_pipelines(
    mut commands: Commands,
    pipeline: Res<PostProcessPipeline>,
    mut pipelines: ResMut<SpecializedComputePipelines<PostProcessPipeline>>,
    mut pipeline_cache: ResMut<PipelineCache>,
) {
    let demodulation = {
        let key = PostProcessPipelineKey::from_entry_point(PostProcessEntryPoint::Demodulation);
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };
    let denoise_direct = [0, 1, 2, 3].map(|level| {
        let mut key = PostProcessPipelineKey::from_entry_point(PostProcessEntryPoint::Denoise);
        key |= PostProcessPipelineKey::from_denoise_level(level);
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    });
    let denoise = [0, 1, 2, 3].map(|level| {
        let mut key = PostProcessPipelineKey::from_entry_point(PostProcessEntryPoint::Denoise);
        key |= PostProcessPipelineKey::from_denoise_level(level);
        key |= PostProcessPipelineKey::FIREFLY_FILTERING_BITS;
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    });

    let tone_mapping = {
        let key = PostProcessPipelineKey::from_entry_point(PostProcessEntryPoint::ToneMapping);
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };

    let taa_jasmine = {
        let key = PostProcessPipelineKey::from_entry_point(PostProcessEntryPoint::TaaJasmine);
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };

    let smaa_tu4x = {
        let key = PostProcessPipelineKey::from_entry_point(PostProcessEntryPoint::SmaaTu4x);
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };
    let smaa_tu4x_extrapolate = {
        let key =
            PostProcessPipelineKey::from_entry_point(PostProcessEntryPoint::SmaaTu4xExtrapolate);
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };

    let upscale = {
        let key = PostProcessPipelineKey::from_entry_point(PostProcessEntryPoint::Upscale);
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };
    let upscale_sharpen = {
        let key = PostProcessPipelineKey::from_entry_point(PostProcessEntryPoint::UpscaleSharpen);
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };

    commands.insert_resource(CachedPostProcessPipelines {
        demodulation,
        denoise_direct,
        denoise,
        tone_mapping,
        taa_jasmine,
        smaa_tu4x,
        smaa_tu4x_extrapolate,
        upscale,
        upscale_sharpen,
    })
}

#[derive(Component, Clone)]
pub struct PostProcessBindGroup {
    pub sampler: BindGroup,
    pub denoise_internal: BindGroup,
    pub denoise_render: Vec<BindGroup>,
    pub tone_mapping: BindGroup,
    pub tone_mapping_output: BindGroup,
    pub smaa: BindGroup,
    pub smaa_output: BindGroup,
    pub taa: BindGroup,
    pub taa_output: BindGroup,
    pub upscale: BindGroup,
    pub upscale_output: BindGroup,
    pub upscale_sharpen: BindGroup,
    pub upscale_sharpen_output: BindGroup,
}

#[allow(clippy::type_complexity)]
fn queue_post_process_bind_groups(
    mut commands: Commands,
    render_device: Res<RenderDevice>,
    pipeline: Res<PostProcessPipeline>,
    fsr_constants_uniforms: Res<ComponentUniforms<FsrConstantsUniform>>,
    query: Query<
        (
            Entity,
            &LightTextures,
            &PostProcessTextures,
            &HikariSettings,
        ),
        With<ExtractedCamera>,
    >,
) {
    let fsr_constants_binding = match fsr_constants_uniforms.binding() {
        Some(binding) => binding,
        None => return,
    };

    for (entity, light, post_process, settings) in &query {
        let current = post_process.head;
        let previous = 1 - current;

        let sampler = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.sampler_layout,
            entries: &[
                BindGroupEntry {
                    binding: 0,
                    resource: BindingResource::Sampler(&post_process.nearest_sampler),
                },
                BindGroupEntry {
                    binding: 1,
                    resource: BindingResource::Sampler(&post_process.linear_sampler),
                },
            ],
        });

        let denoise_internal = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.denoise_internal_layout,
            entries: &[
                BindGroupEntry {
                    binding: 0,
                    resource: BindingResource::TextureView(&post_process.denoise_internal[0]),
                },
                BindGroupEntry {
                    binding: 1,
                    resource: BindingResource::TextureView(&post_process.denoise_internal[1]),
                },
                BindGroupEntry {
                    binding: 2,
                    resource: BindingResource::TextureView(&post_process.denoise_internal[2]),
                },
                BindGroupEntry {
                    binding: 3,
                    resource: BindingResource::TextureView(&post_process.denoise_internal[3]),
                },
                BindGroupEntry {
                    binding: 4,
                    resource: BindingResource::TextureView(&post_process.denoise_internal_variance),
                },
            ],
        });

        let mut denoise_render = [0, 1, 2]
            .map(|id| {
                render_device.create_bind_group(&BindGroupDescriptor {
                    label: None,
                    layout: &pipeline.denoise_render_layout,
                    entries: &[
                        BindGroupEntry {
                            binding: 0,
                            resource: BindingResource::TextureView(&light.albedo),
                        },
                        BindGroupEntry {
                            binding: 1,
                            resource: BindingResource::TextureView(&light.variance[id]),
                        },
                        BindGroupEntry {
                            binding: 2,
                            resource: BindingResource::TextureView(&light.render[id]),
                        },
                        BindGroupEntry {
                            binding: 3,
                            resource: BindingResource::TextureView(
                                &post_process.denoise_render[id],
                            ),
                        },
                    ],
                })
            })
            .to_vec();

        let (direct_render, emissive_render, mut indirect_render) = match settings.denoise {
            false => (&light.render[0], &light.render[1], &light.render[2]),
            true => (
                &post_process.denoise_render[0],
                &post_process.denoise_render[1],
                &post_process.denoise_render[2],
            ),
        };

        if settings.indirect_bounces == 0 {
            // Do not denoise when there is no indirect rendering pass.
            denoise_render.pop();
            // Use fallback texture when there is no indirect denoise pass.
            indirect_render = &post_process.fallback;
        }

        let tone_mapping = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.tone_mapping_layout,
            entries: &[
                BindGroupEntry {
                    binding: 0,
                    resource: BindingResource::TextureView(direct_render),
                },
                BindGroupEntry {
                    binding: 1,
                    resource: BindingResource::TextureView(emissive_render),
                },
                BindGroupEntry {
                    binding: 2,
                    resource: BindingResource::TextureView(indirect_render),
                },
            ],
        });
        let tone_mapping_output = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.output_layout,
            entries: &[BindGroupEntry {
                binding: 0,
                resource: BindingResource::TextureView(&post_process.tone_mapping_output[current]),
            }],
        });

        let smaa = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.smaa_layout,
            entries: &[
                BindGroupEntry {
                    binding: 0,
                    resource: BindingResource::TextureView(
                        &post_process.tone_mapping_output[previous],
                    ),
                },
                BindGroupEntry {
                    binding: 1,
                    resource: BindingResource::TextureView(
                        &post_process.tone_mapping_output[current],
                    ),
                },
            ],
        });
        let smaa_output = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.output_layout,
            entries: &[BindGroupEntry {
                binding: 0,
                resource: BindingResource::TextureView(&post_process.upscale_output[0]),
            }],
        });

        let taa_input_texture = match settings.upscale {
            Upscale::SmaaTu4x { .. } => &post_process.upscale_output[0],
            _ => &post_process.tone_mapping_output[current],
        };
        let taa = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.taa_layout,
            entries: &[
                BindGroupEntry {
                    binding: 0,
                    resource: BindingResource::TextureView(&post_process.taa_output[previous]),
                },
                BindGroupEntry {
                    binding: 1,
                    resource: BindingResource::TextureView(taa_input_texture),
                },
            ],
        });
        let taa_output = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.output_layout,
            entries: &[BindGroupEntry {
                binding: 0,
                resource: BindingResource::TextureView(&post_process.taa_output[current]),
            }],
        });

        let upscale_input_texture = match settings.taa {
            Taa::Jasmine => &post_process.taa_output[current],
            Taa::None => &post_process.tone_mapping_output[current],
        };

        let upscale = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.upscale_layout,
            entries: &[
                BindGroupEntry {
                    binding: 0,
                    resource: fsr_constants_binding.clone(),
                },
                BindGroupEntry {
                    binding: 1,
                    resource: BindingResource::TextureView(upscale_input_texture),
                },
            ],
        });
        let upscale_output = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.output_layout,
            entries: &[BindGroupEntry {
                binding: 0,
                resource: BindingResource::TextureView(&post_process.upscale_output[0]),
            }],
        });

        let upscale_sharpen = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.upscale_layout,
            entries: &[
                BindGroupEntry {
                    binding: 0,
                    resource: fsr_constants_binding.clone(),
                },
                BindGroupEntry {
                    binding: 1,
                    resource: BindingResource::TextureView(&post_process.upscale_output[0]),
                },
            ],
        });
        let upscale_sharpen_output = render_device.create_bind_group(&BindGroupDescriptor {
            label: None,
            layout: &pipeline.output_layout,
            entries: &[BindGroupEntry {
                binding: 0,
                resource: BindingResource::TextureView(&post_process.upscale_output[1]),
            }],
        });

        commands.entity(entity).insert(PostProcessBindGroup {
            sampler,
            denoise_internal,
            denoise_render,
            tone_mapping,
            tone_mapping_output,
            smaa,
            smaa_output,
            taa,
            taa_output,
            upscale,
            upscale_output,
            upscale_sharpen,
            upscale_sharpen_output,
        });
    }
}

#[allow(clippy::type_complexity)]
pub struct PostProcessNode {
    query: QueryState<(
        &'static ExtractedCamera,
        &'static DynamicUniformIndex<FrameUniform>,
        &'static ViewUniformOffset,
        &'static PreviousViewUniformOffset,
        &'static ViewLightsUniformOffset,
        &'static DeferredBindGroup,
        &'static PostProcessBindGroup,
        &'static DynamicUniformIndex<FsrConstantsUniform>,
        &'static HikariSettings,
    )>,
}

impl PostProcessNode {
    pub const IN_VIEW: &'static str = "view";

    pub fn new(world: &mut World) -> Self {
        Self {
            query: world.query_filtered(),
        }
    }
}

impl Node for PostProcessNode {
    fn input(&self) -> Vec<SlotInfo> {
        vec![SlotInfo::new(Self::IN_VIEW, SlotType::Entity)]
    }

    fn update(&mut self, world: &mut World) {
        self.query.update_archetypes(world);
    }

    fn run(
        &self,
        graph: &mut RenderGraphContext,
        render_context: &mut RenderContext,
        world: &World,
    ) -> Result<(), NodeRunError> {
        let entity = graph.get_input_entity(Self::IN_VIEW)?;
        let (
            camera,
            frame_uniform,
            view_uniform,
            previous_view_uniform,
            view_lights,
            deferred_bind_group,
            post_process_bind_group,
            fsr_constants_uniform,
            settings,
        ) = match self.query.get_manual(world, entity) {
            Ok(query) => query,
            Err(_) => return Ok(()),
        };
        let view_bind_group = match world.get_resource::<PrepassBindGroup>() {
            Some(bind_group) => &bind_group.view,
            None => return Ok(()),
        };

        let pipelines = world.resource::<CachedPostProcessPipelines>();
        let pipeline_cache = world.resource::<PipelineCache>();

        let size = camera.physical_target_size.unwrap();
        let scale = settings.upscale.ratio().recip();
        let mut scaled_size = (scale * size.as_vec2()).ceil().as_uvec2();

        let mut pass = render_context
            .command_encoder
            .begin_compute_pass(&ComputePassDescriptor::default());

        pass.set_bind_group(
            0,
            view_bind_group,
            &[
                frame_uniform.index(),
                view_uniform.offset,
                previous_view_uniform.offset,
                view_lights.offset,
            ],
        );
        pass.set_bind_group(1, &deferred_bind_group.0, &[]);
        pass.set_bind_group(2, &post_process_bind_group.sampler, &[]);

        if settings.denoise {
            pass.set_bind_group(3, &post_process_bind_group.denoise_internal, &[]);

            let denoise_pipelines = [
                pipelines.denoise_direct,
                pipelines.denoise,
                pipelines.denoise,
            ];

            for (render_bind_group, denoise) in post_process_bind_group
                .denoise_render
                .iter()
                .zip(denoise_pipelines.iter())
            {
                pass.set_bind_group(4, render_bind_group, &[]);

                if let Some(pipeline) = pipeline_cache.get_compute_pipeline(pipelines.demodulation)
                {
                    pass.set_pipeline(pipeline);

                    let count = (scaled_size + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
                    pass.dispatch_workgroups(count.x, count.y, 1);
                }

                for pipeline in denoise
                    .iter()
                    .filter_map(|pipeline| pipeline_cache.get_compute_pipeline(*pipeline))
                {
                    pass.set_pipeline(pipeline);

                    let count = (scaled_size + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
                    pass.dispatch_workgroups(count.x, count.y, 1);
                }
            }
        }

        pass.set_bind_group(3, &post_process_bind_group.tone_mapping, &[]);
        pass.set_bind_group(4, &post_process_bind_group.tone_mapping_output, &[]);

        if let Some(pipeline) = pipeline_cache.get_compute_pipeline(pipelines.tone_mapping) {
            pass.set_pipeline(pipeline);

            let count = (scaled_size + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
            pass.dispatch_workgroups(count.x, count.y, 1);
        }

        if matches!(settings.upscale, Upscale::SmaaTu4x { .. }) {
            pass.set_bind_group(3, &post_process_bind_group.smaa, &[]);
            pass.set_bind_group(4, &post_process_bind_group.smaa_output, &[]);

            if let Some(pipeline) = pipeline_cache.get_compute_pipeline(pipelines.smaa_tu4x) {
                pass.set_pipeline(pipeline);

                let count = (scaled_size + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
                pass.dispatch_workgroups(count.x, count.y, 1);
            }

            if let Some(pipeline) =
                pipeline_cache.get_compute_pipeline(pipelines.smaa_tu4x_extrapolate)
            {
                pass.set_pipeline(pipeline);

                let count = (scaled_size + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
                pass.dispatch_workgroups(count.x, count.y, 1);
            }

            // The in-out size after the upscale pass is 4x larger.
            scaled_size *= 2;
        }

        if matches!(settings.taa, Taa::Jasmine) {
            pass.set_bind_group(3, &post_process_bind_group.taa, &[]);
            pass.set_bind_group(4, &post_process_bind_group.taa_output, &[]);

            // if let Some(pipeline) = pipeline_cache.get_compute_pipeline(pipelines.taa_short) {
            //     pass.set_pipeline(pipeline);

            //     let count = (scaled_size + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
            //     pass.dispatch_workgroups(count.x, count.y, 1);
            // }

            if let Some(pipeline) = pipeline_cache.get_compute_pipeline(pipelines.taa_jasmine) {
                pass.set_pipeline(pipeline);

                let count = (scaled_size + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
                pass.dispatch_workgroups(count.x, count.y, 1);
            }
        }

        if matches!(settings.upscale, Upscale::Fsr1 { .. }) {
            pass.set_bind_group(0, &post_process_bind_group.sampler, &[]);
            pass.set_bind_group(
                1,
                &post_process_bind_group.upscale,
                &[fsr_constants_uniform.index()],
            );
            pass.set_bind_group(2, &post_process_bind_group.upscale_output, &[]);

            if let Some(pipeline) = pipeline_cache.get_compute_pipeline(pipelines.upscale) {
                pass.set_pipeline(pipeline);

                let count = (size * 2 + 15) / 16;
                pass.dispatch_workgroups(count.x, count.y, 1);
            }

            pass.set_bind_group(
                1,
                &post_process_bind_group.upscale_sharpen,
                &[fsr_constants_uniform.index()],
            );
            pass.set_bind_group(2, &post_process_bind_group.upscale_sharpen_output, &[]);

            if let Some(pipeline) = pipeline_cache.get_compute_pipeline(pipelines.upscale_sharpen) {
                pass.set_pipeline(pipeline);

                let count = (size * 2 + 15) / 16;
                pass.dispatch_workgroups(count.x, count.y, 1);
            }
        }

        Ok(())
    }

src/view.rs (line 172)

    fn extract_component((settings, counter): QueryItem<Self::Query>) -> Self {
        let HikariSettings {
            direct_validate_interval,
            emissive_validate_interval,
            max_temporal_reuse_count,
            max_spatial_reuse_count,
            max_reservoir_lifetime,
            solar_angle,
            indirect_bounces,
            max_indirect_luminance,
            clear_color,
            temporal_reuse,
            emissive_spatial_reuse,
            indirect_spatial_reuse,
            ..
        } = settings.clone();

        let number = counter.0 as u32;
        let direct_validate_interval = direct_validate_interval as u32;
        let emissive_validate_interval = emissive_validate_interval as u32;
        let indirect_bounces = indirect_bounces as u32;
        let clear_color = clear_color.into();
        let max_temporal_reuse_count = max_temporal_reuse_count as u32;
        let max_spatial_reuse_count = max_spatial_reuse_count as u32;
        let temporal_reuse = temporal_reuse.into();
        let emissive_spatial_reuse = emissive_spatial_reuse.into();
        let indirect_spatial_reuse = indirect_spatial_reuse.into();
        let upscale_ratio = settings.upscale.ratio();

        Self {
            kernel: KERNEL,
            halton: HALTON,
            clear_color,
            number,
            direct_validate_interval,
            emissive_validate_interval,
            indirect_bounces,
            temporal_reuse,
            emissive_spatial_reuse,
            indirect_spatial_reuse,
            max_temporal_reuse_count,
            max_spatial_reuse_count,
            max_reservoir_lifetime,
            solar_angle,
            max_indirect_luminance,
            upscale_ratio,
        }
    }

src/light.rs (line 318)

fn prepare_light_textures(
    mut commands: Commands,
    render_device: Res<RenderDevice>,
    render_queue: Res<RenderQueue>,
    mut texture_cache: ResMut<TextureCache>,
    mut reservoir_cache: ResMut<ReservoirCache>,
    cameras: Query<(Entity, &ExtractedCamera, &FrameCounter, &HikariSettings)>,
) {
    for (entity, camera, counter, settings) in &cameras {
        if let Some(size) = camera.physical_target_size {
            let texture_usage = TextureUsages::TEXTURE_BINDING | TextureUsages::STORAGE_BINDING;
            let scale = settings.upscale.ratio().recip();
            let scaled_size = (scale * size.as_vec2()).ceil().as_uvec2();
            let mut create_texture = |texture_format, size: UVec2| {
                let extent = Extent3d {
                    width: size.x,
                    height: size.y,
                    depth_or_array_layers: 1,
                };
                texture_cache
                    .get(
                        &render_device,
                        TextureDescriptor {
                            label: None,
                            size: extent,
                            mip_level_count: 1,
                            sample_count: 1,
                            dimension: TextureDimension::D2,
                            format: texture_format,
                            usage: texture_usage,
                        },
                    )
                    .default_view
            };

            if match reservoir_cache.get(&entity) {
                Some(reservoirs) => {
                    let len = (size.x * size.y) as usize;
                    reservoirs
                        .iter()
                        .any(|buffer| buffer.get().data.len() != len)
                }
                None => true,
            } {
                // Reservoirs of this entity should be updated.
                let len = (size.x * size.y) as usize;
                let reservoirs = (0..10)
                    .map(|_| {
                        let mut buffer = StorageBuffer::from(GpuReservoirBuffer {
                            data: vec![GpuPackedReservoir::default(); len],
                        });
                        buffer.write_buffer(&render_device, &render_queue);
                        buffer
                    })
                    .collect();
                reservoir_cache.insert(entity, reservoirs);
            }

            macro_rules! create_texture_array {
                [$texture_format:ident, $size:ident; $count:literal] => {
                    [(); $count].map(|_| create_texture($texture_format, $size))
                };
            }

            let variance = create_texture_array![VARIANCE_TEXTURE_FORMAT, scaled_size; 3];
            let render = create_texture_array![RENDER_TEXTURE_FORMAT, scaled_size; 3];
            let albedo = create_texture(ALBEDO_TEXTURE_FORMAT, size);

            commands.entity(entity).insert(LightTextures {
                head: counter.0 % 2,
                albedo,
                variance,
                render,
            });
        }
    }
}

#[derive(Resource)]
pub struct CachedLightPipelines {
    full_screen_albedo: CachedComputePipelineId,
    direct_lit: CachedComputePipelineId,
    direct_emissive: CachedComputePipelineId,
    indirect: CachedComputePipelineId,
    indirect_multiple_bounces: CachedComputePipelineId,
    emissive_spatial_reuse: CachedComputePipelineId,
    indirect_spatial_reuse: CachedComputePipelineId,
}

fn queue_light_pipelines(
    mut commands: Commands,
    pipeline: Res<LightPipeline>,
    mut pipelines: ResMut<SpecializedComputePipelines<LightPipeline>>,
    mut pipeline_cache: ResMut<PipelineCache>,
) {
    let key = LightPipelineKey::from_texture_count(pipeline.texture_count);

    let full_screen_albedo = {
        let key = key | LightPipelineKey::from_entry_point(LightEntryPoint::FullScreenAlbedo);
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };

    let direct_lit = {
        let key = key
            | LightPipelineKey::from_entry_point(LightEntryPoint::DirectLit)
            | LightPipelineKey::RENDER_EMISSIVE_BIT;
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };
    let direct_emissive = {
        let key = key
            | LightPipelineKey::from_entry_point(LightEntryPoint::DirectLit)
            | LightPipelineKey::EMISSIVE_LIT_BIT;
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };

    let indirect = {
        let key = key | LightPipelineKey::from_entry_point(LightEntryPoint::IndirectLitAmbient);
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };
    let indirect_multiple_bounces = {
        let key = key
            | LightPipelineKey::from_entry_point(LightEntryPoint::IndirectLitAmbient)
            | LightPipelineKey::MULTIPLE_BOUNCES_BIT;
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };

    let emissive_spatial_reuse = {
        let key = key
            | LightPipelineKey::from_entry_point(LightEntryPoint::SpatialReuse)
            | LightPipelineKey::EMISSIVE_LIT_BIT;
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };
    let indirect_spatial_reuse = {
        let key = key | LightPipelineKey::from_entry_point(LightEntryPoint::SpatialReuse);
        pipelines.specialize(&mut pipeline_cache, &pipeline, key)
    };

    commands.insert_resource(CachedLightPipelines {
        full_screen_albedo,
        direct_lit,
        direct_emissive,
        indirect,
        indirect_multiple_bounces,
        emissive_spatial_reuse,
        indirect_spatial_reuse,
    })
}

#[derive(Component, Clone)]
pub struct LightBindGroup {
    pub noise: BindGroup,
    pub render: [BindGroup; 3],
    pub reservoir: [BindGroup; 3],
}

#[allow(clippy::too_many_arguments)]
fn queue_light_bind_groups(
    mut commands: Commands,
    render_device: Res<RenderDevice>,
    pipeline: Res<LightPipeline>,
    noise: Res<NoiseTextures>,
    images: Res<RenderAssets<Image>>,
    fallback: Res<FallbackImage>,
    reservoir_cache: Res<ReservoirCache>,
    query: Query<(Entity, &LightTextures), With<ExtractedCamera>>,
) {
    for (entity, light) in &query {
        let reservoirs = reservoir_cache.get(&entity).unwrap();
        if let Some(reservoir_bindings) = reservoirs
            .iter()
            .map(|buffer| buffer.binding())
            .collect::<Option<Vec<_>>>()
        {
            let current = light.head;
            let previous = 1 - current;

            let noise = match noise.as_bind_group(
                &pipeline.noise_layout,
                &render_device,
                &images,
                &fallback,
            ) {
                Ok(noise) => noise,
                Err(_) => continue,
            }
            .bind_group;

            let render = [0, 1, 2].map(|id| {
                let variance = &light.variance[id];
                let render = &light.render[id];

                render_device.create_bind_group(&BindGroupDescriptor {
                    label: None,
                    layout: &pipeline.render_layout,
                    entries: &[
                        BindGroupEntry {
                            binding: 0,
                            resource: BindingResource::TextureView(&light.albedo),
                        },
                        BindGroupEntry {
                            binding: 1,
                            resource: BindingResource::TextureView(variance),
                        },
                        BindGroupEntry {
                            binding: 2,
                            resource: BindingResource::TextureView(render),
                        },
                    ],
                })
            });

            let reservoir = [(0, 4), (2, 4), (6, 8)].map(|(temporal, spatial)| {
                let current_temporal = reservoir_bindings[current + temporal].clone();
                let previous_temporal = reservoir_bindings[previous + temporal].clone();
                let current_spatial = reservoir_bindings[current + spatial].clone();
                let previous_spatial = reservoir_bindings[previous + spatial].clone();

                render_device.create_bind_group(&BindGroupDescriptor {
                    label: None,
                    layout: &pipeline.reservoir_layout,
                    entries: &[
                        BindGroupEntry {
                            binding: 0,
                            resource: current_temporal,
                        },
                        BindGroupEntry {
                            binding: 1,
                            resource: previous_temporal,
                        },
                        BindGroupEntry {
                            binding: 2,
                            resource: current_spatial,
                        },
                        BindGroupEntry {
                            binding: 3,
                            resource: previous_spatial,
                        },
                    ],
                })
            });

            commands.entity(entity).insert(LightBindGroup {
                noise,
                render,
                reservoir,
            });
        }
    }
}

#[allow(clippy::type_complexity)]
pub struct LightNode {
    query: QueryState<(
        &'static ExtractedCamera,
        &'static DynamicUniformIndex<FrameUniform>,
        &'static ViewUniformOffset,
        &'static PreviousViewUniformOffset,
        &'static ViewLightsUniformOffset,
        &'static DeferredBindGroup,
        &'static LightBindGroup,
        &'static HikariSettings,
    )>,
}

impl LightNode {
    pub const IN_VIEW: &'static str = "view";

    pub fn new(world: &mut World) -> Self {
        Self {
            query: world.query_filtered(),
        }
    }
}

impl Node for LightNode {
    fn input(&self) -> Vec<SlotInfo> {
        vec![SlotInfo::new(Self::IN_VIEW, SlotType::Entity)]
    }

    fn update(&mut self, world: &mut World) {
        self.query.update_archetypes(world);
    }

    fn run(
        &self,
        graph: &mut RenderGraphContext,
        render_context: &mut RenderContext,
        world: &World,
    ) -> Result<(), NodeRunError> {
        let entity = graph.get_input_entity(Self::IN_VIEW)?;
        let (
            camera,
            frame_uniform,
            view_uniform,
            previous_view_uniform,
            view_lights,
            deferred_bind_group,
            light_bind_group,
            settings,
        ) = match self.query.get_manual(world, entity) {
            Ok(query) => query,
            Err(_) => return Ok(()),
        };
        let view_bind_group = match world.get_resource::<PrepassBindGroup>() {
            Some(bind_group) => &bind_group.view,
            None => return Ok(()),
        };
        let mesh_material_bind_group = match world.get_resource::<MeshMaterialBindGroup>() {
            Some(bind_group) => bind_group,
            None => return Ok(()),
        };

        let pipelines = world.resource::<CachedLightPipelines>();
        let pipeline_cache = world.resource::<PipelineCache>();

        let size = camera.physical_target_size.unwrap();
        let scale = settings.upscale.ratio().recip();
        let scaled_size = (scale * size.as_vec2()).ceil().as_uvec2();

        let mut pass = render_context
            .command_encoder
            .begin_compute_pass(&ComputePassDescriptor::default());

        pass.set_bind_group(
            0,
            view_bind_group,
            &[
                frame_uniform.index(),
                view_uniform.offset,
                previous_view_uniform.offset,
                view_lights.offset,
            ],
        );
        pass.set_bind_group(1, &deferred_bind_group.0, &[]);
        pass.set_bind_group(2, &mesh_material_bind_group.mesh_material, &[]);
        pass.set_bind_group(3, &mesh_material_bind_group.texture, &[]);
        pass.set_bind_group(4, &light_bind_group.noise, &[]);

        // Full screen albedo pass.
        if let Some(pipeline) = pipeline_cache.get_compute_pipeline(pipelines.full_screen_albedo) {
            pass.set_bind_group(5, &light_bind_group.render[0], &[]);
            pass.set_bind_group(6, &light_bind_group.reservoir[0], &[]);
            pass.set_pipeline(pipeline);

            let count = (size + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
            pass.dispatch_workgroups(count.x, count.y, 1);
        }

        // Direct, emissive and indirect passes.
        for (render, reservoir, temporal_pipeline, spatial_pipeline, enable_spatial_reuse) in
            multizip((
                light_bind_group.render.iter(),
                light_bind_group.reservoir.iter(),
                [
                    &pipelines.direct_lit,
                    &pipelines.direct_emissive,
                    match settings.indirect_bounces {
                        x if x < 2 => &pipelines.indirect,
                        _ => &pipelines.indirect_multiple_bounces,
                    },
                ],
                [
                    None,
                    Some(&pipelines.emissive_spatial_reuse),
                    Some(&pipelines.indirect_spatial_reuse),
                ],
                [
                    false,
                    settings.emissive_spatial_reuse,
                    settings.indirect_spatial_reuse,
                ],
            ))
        {
            pass.set_bind_group(5, render, &[]);
            pass.set_bind_group(6, reservoir, &[]);

            if let Some(pipeline) = pipeline_cache.get_compute_pipeline(*temporal_pipeline) {
                pass.set_pipeline(pipeline);

                let count = (scaled_size + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
                pass.dispatch_workgroups(count.x, count.y, 1);

                if let Some(pipeline) = spatial_pipeline
                    .filter(|_| enable_spatial_reuse)
                    .and_then(|pipeline| pipeline_cache.get_compute_pipeline(*pipeline))
                {
                    pass.set_pipeline(pipeline);

                    let count = (scaled_size + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
                    pass.dispatch_workgroups(count.x, count.y, 1);
                }
            }
        }

        Ok(())
    }

pub fn sharpness(&self) -> f32

Examples found in repository

src/post_process.rs (line 530)

    fn extract_component((camera, settings): QueryItem<Self::Query>) -> Self {
        let size = camera.physical_target_size().unwrap_or_default();
        let scale = settings.upscale.ratio().recip();
        let scaled_size = (scale * size.as_vec2()).ceil();
        Self {
            input_viewport_in_pixels: scaled_size,
            input_size_in_pixels: scaled_size,
            output_size_in_pixels: size.as_vec2(),
            sharpness: settings.upscale.sharpness(),
            hdr: 0,
        }
    }

Trait Implementations

impl Clone for Upscale

fn clone(&self) -> Upscale

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Upscale

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Upscale

fn default() -> Self

Returns the “default value” for a type.

impl Enum for Upscale

fn field(&self, __name_param: &str) -> Option<&dyn Reflect>

Returns a reference to the value of the field (in the current variant) with the given name.

fn field_at(&self, __index_param: usize) -> Option<&dyn Reflect>

Returns a reference to the value of the field (in the current variant) at the given index.

fn field_mut(&mut self, __name_param: &str) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field (in the current variant) with the given name.

fn field_at_mut(&mut self, __index_param: usize) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field (in the current variant) at the given index.

fn index_of(&self, __name_param: &str) -> Option<usize>

Returns the index of the field (in the current variant) with the given name.

fn name_at(&self, __index_param: usize) -> Option<&str>

Returns the name of the field (in the current variant) with the given index.

fn iter_fields(&self) -> VariantFieldIter<'_>

Returns an iterator over the values of the current variant’s fields.

fn field_len(&self) -> usize

Returns the number of fields in the current variant.

fn variant_name(&self) -> &str

The name of the current variant.

fn variant_index(&self) -> usize

The index of the current variant.

fn variant_type(&self) -> VariantType

The type of the current variant.

fn clone_dynamic(&self) -> DynamicEnum

fn is_variant(&self, variant_type: VariantType) -> bool

Returns true if the current variant’s type matches the given one.

fn variant_path(&self) -> String

Returns the full path to the current variant.

impl GetTypeRegistration for Upscale

fn get_type_registration() -> TypeRegistration

impl Reflect for Upscale

fn type_name(&self) -> &str

Returns the type name of the underlying type.

fn get_type_info(&self) -> &'static TypeInfo

Returns the [TypeInfo] of the underlying type.

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable reflected value.

fn clone_value(&self) -> Box<dyn Reflect>

Clones the value as a Reflect trait object.

fn set(
    &mut self,
    __value_param: Box<dyn Reflect>
) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

fn apply(&mut self, __value_param: &dyn Reflect)

Applies a reflected value to this value.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Debug formatter for the value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

impl Typed for Upscale

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for Upscale