You've already forked godot
mirror of
https://github.com/godotengine/godot.git
synced 2025-11-04 12:00:25 +00:00
Overhaul screen space reflections.
This commit is contained in:
Skyth
@@ -31,6 +31,7 @@
|
||||
#include "ss_effects.h"
|
||||
|
||||
#include "core/config/project_settings.h"
|
||||
#include "servers/rendering/renderer_rd/effects/copy_effects.h"
|
||||
#include "servers/rendering/renderer_rd/storage_rd/material_storage.h"
|
||||
#include "servers/rendering/renderer_rd/storage_rd/render_scene_buffers_rd.h"
|
||||
#include "servers/rendering/renderer_rd/uniform_set_cache_rd.h"
|
||||
@@ -277,62 +278,67 @@ SSEffects::SSEffects() {
|
||||
}
|
||||
|
||||
// Screen Space Reflections
|
||||
ssr_roughness_quality = RS::EnvironmentSSRRoughnessQuality(int(GLOBAL_GET("rendering/environment/screen_space_reflection/roughness_quality")));
|
||||
ssr_half_size = GLOBAL_GET("rendering/environment/screen_space_reflection/half_size");
|
||||
|
||||
{
|
||||
Vector<RD::PipelineSpecializationConstant> specialization_constants;
|
||||
|
||||
{
|
||||
RD::PipelineSpecializationConstant sc;
|
||||
sc.type = RD::PIPELINE_SPECIALIZATION_CONSTANT_TYPE_BOOL;
|
||||
sc.constant_id = 0; // SSR_USE_FULL_PROJECTION_MATRIX
|
||||
sc.bool_value = false;
|
||||
specialization_constants.push_back(sc);
|
||||
Vector<String> ssr_downsample_modes;
|
||||
ssr_downsample_modes.push_back("\n"); // SCREEN_SPACE_REFLECTION_DOWNSAMPLE_DEFAULT
|
||||
ssr_downsample_modes.push_back("\n#define MODE_ODD_WIDTH\n"); // SCREEN_SPACE_REFLECTION_DOWNSAMPLE_ODD_WIDTH
|
||||
ssr_downsample_modes.push_back("\n#define MODE_ODD_HEIGHT\n"); // SCREEN_SPACE_REFLECTION_DOWNSAMPLE_ODD_HEIGHT
|
||||
ssr_downsample_modes.push_back("\n#define MODE_ODD_WIDTH\n#define MODE_ODD_HEIGHT\n"); // SCREEN_SPACE_REFLECTION_DOWNSAMPLE_ODD_WIDTH_AND_HEIGHT
|
||||
|
||||
ssr.downsample_shader.initialize(ssr_downsample_modes);
|
||||
ssr.downsample_shader_version = ssr.downsample_shader.version_create();
|
||||
|
||||
for (uint32_t i = 0; i < SCREEN_SPACE_REFLECTION_DOWNSAMPLE_MAX; i++) {
|
||||
ssr.downsample_pipelines[i].create_compute_pipeline(ssr.downsample_shader.version_get_shader(ssr.downsample_shader_version, i));
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
Vector<String> ssr_scale_modes;
|
||||
ssr_scale_modes.push_back("\n");
|
||||
Vector<String> ssr_hiz_modes;
|
||||
ssr_hiz_modes.push_back("\n"); // SCREEN_SPACE_REFLECTION_HIZ_DEFAULT
|
||||
ssr_hiz_modes.push_back("\n#define MODE_ODD_WIDTH\n"); // SCREEN_SPACE_REFLECTION_HIZ_ODD_WIDTH
|
||||
ssr_hiz_modes.push_back("\n#define MODE_ODD_HEIGHT\n"); // SCREEN_SPACE_REFLECTION_HIZ_ODD_HEIGHT
|
||||
ssr_hiz_modes.push_back("\n#define MODE_ODD_WIDTH\n#define MODE_ODD_HEIGHT\n"); // SCREEN_SPACE_REFLECTION_HIZ_ODD_WIDTH_AND_HEIGHT
|
||||
|
||||
ssr_scale.shader.initialize(ssr_scale_modes);
|
||||
ssr_scale.shader_version = ssr_scale.shader.version_create();
|
||||
ssr.hiz_shader.initialize(ssr_hiz_modes);
|
||||
ssr.hiz_shader_version = ssr.hiz_shader.version_create();
|
||||
|
||||
for (int v = 0; v < SSR_VARIATIONS; v++) {
|
||||
specialization_constants.ptrw()[0].bool_value = (v & SSR_MULTIVIEW) ? true : false;
|
||||
ssr_scale.pipelines[v].create_compute_pipeline(ssr_scale.shader.version_get_shader(ssr_scale.shader_version, 0), specialization_constants);
|
||||
for (uint32_t i = 0; i < SCREEN_SPACE_REFLECTION_HIZ_MAX; i++) {
|
||||
ssr.hiz_pipelines[i].create_compute_pipeline(ssr.hiz_shader.version_get_shader(ssr.hiz_shader_version, i));
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
Vector<String> ssr_modes;
|
||||
ssr_modes.push_back("\n"); // SCREEN_SPACE_REFLECTION_NORMAL
|
||||
ssr_modes.push_back("\n#define MODE_ROUGH\n"); // SCREEN_SPACE_REFLECTION_ROUGH
|
||||
ssr_modes.push_back("\n");
|
||||
|
||||
ssr.shader.initialize(ssr_modes);
|
||||
ssr.shader_version = ssr.shader.version_create();
|
||||
ssr.ssr_shader.initialize(ssr_modes);
|
||||
ssr.ssr_shader_version = ssr.ssr_shader.version_create();
|
||||
|
||||
for (int v = 0; v < SSR_VARIATIONS; v++) {
|
||||
specialization_constants.ptrw()[0].bool_value = (v & SSR_MULTIVIEW) ? true : false;
|
||||
for (int i = 0; i < SCREEN_SPACE_REFLECTION_MAX; i++) {
|
||||
ssr.pipelines[v][i].create_compute_pipeline(ssr.shader.version_get_shader(ssr.shader_version, i), specialization_constants);
|
||||
}
|
||||
}
|
||||
ssr.ssr_pipeline.create_compute_pipeline(ssr.ssr_shader.version_get_shader(ssr.ssr_shader_version, 0));
|
||||
}
|
||||
|
||||
{
|
||||
Vector<String> ssr_filter_modes;
|
||||
ssr_filter_modes.push_back("\n"); // SCREEN_SPACE_REFLECTION_FILTER_HORIZONTAL
|
||||
ssr_filter_modes.push_back("\n#define VERTICAL_PASS\n"); // SCREEN_SPACE_REFLECTION_FILTER_VERTICAL
|
||||
ssr_filter_modes.push_back("\n");
|
||||
|
||||
ssr_filter.shader.initialize(ssr_filter_modes);
|
||||
ssr_filter.shader_version = ssr_filter.shader.version_create();
|
||||
ssr.filter_shader.initialize(ssr_filter_modes);
|
||||
ssr.filter_shader_version = ssr.filter_shader.version_create();
|
||||
|
||||
for (int v = 0; v < SSR_VARIATIONS; v++) {
|
||||
specialization_constants.ptrw()[0].bool_value = (v & SSR_MULTIVIEW) ? true : false;
|
||||
for (int i = 0; i < SCREEN_SPACE_REFLECTION_FILTER_MAX; i++) {
|
||||
ssr_filter.pipelines[v][i].create_compute_pipeline(ssr_filter.shader.version_get_shader(ssr_filter.shader_version, i), specialization_constants);
|
||||
}
|
||||
}
|
||||
ssr.filter_pipeline.create_compute_pipeline(ssr.filter_shader.version_get_shader(ssr.filter_shader_version, 0));
|
||||
}
|
||||
|
||||
{
|
||||
Vector<String> ssr_resolve_modes;
|
||||
ssr_resolve_modes.push_back("\n");
|
||||
|
||||
ssr.resolve_shader.initialize(ssr_resolve_modes);
|
||||
ssr.resolve_shader_version = ssr.resolve_shader.version_create();
|
||||
|
||||
ssr.resolve_pipeline.create_compute_pipeline(ssr.resolve_shader.version_get_shader(ssr.resolve_shader_version, 0));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -357,21 +363,81 @@ SSEffects::SSEffects() {
|
||||
}
|
||||
}
|
||||
|
||||
void SSEffects::allocate_last_frame_buffer(Ref<RenderSceneBuffersRD> p_render_buffers, bool p_use_ssil, bool p_use_ssr) {
|
||||
Size2i last_frame_size = p_render_buffers->get_internal_size();
|
||||
uint32_t mipmaps = 1;
|
||||
uint32_t view_count = p_render_buffers->get_view_count();
|
||||
|
||||
if (!p_use_ssil && p_use_ssr && ssr_half_size) {
|
||||
last_frame_size /= 2;
|
||||
}
|
||||
|
||||
if (p_use_ssil) {
|
||||
mipmaps = 6;
|
||||
}
|
||||
|
||||
bool should_create = true;
|
||||
bool has_texture = p_render_buffers->has_texture(RB_SCOPE_SSLF, RB_LAST_FRAME);
|
||||
|
||||
if (has_texture) {
|
||||
RID last_frame_texture = p_render_buffers->get_texture(RB_SCOPE_SSLF, RB_LAST_FRAME);
|
||||
RD::TextureFormat texture_format = RD::get_singleton()->texture_get_format(last_frame_texture);
|
||||
should_create = texture_format.width != (uint32_t)last_frame_size.width || texture_format.height != (uint32_t)last_frame_size.height || texture_format.mipmaps != mipmaps || texture_format.array_layers != view_count;
|
||||
}
|
||||
|
||||
if (should_create) {
|
||||
if (has_texture) {
|
||||
p_render_buffers->clear_context(RB_SCOPE_SSLF);
|
||||
}
|
||||
|
||||
RID last_frame_texture = p_render_buffers->create_texture(RB_SCOPE_SSLF, RB_LAST_FRAME, RD::DATA_FORMAT_R16G16B16A16_SFLOAT, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT, RD::TEXTURE_SAMPLES_1, last_frame_size, view_count, mipmaps);
|
||||
RD::get_singleton()->texture_clear(last_frame_texture, Color(0, 0, 0, 0), 0, mipmaps, 0, view_count);
|
||||
}
|
||||
}
|
||||
|
||||
void SSEffects::copy_internal_texture_to_last_frame(Ref<RenderSceneBuffersRD> p_render_buffers, CopyEffects &p_copy_effects) {
|
||||
uint32_t mipmaps = p_render_buffers->get_texture_format(RB_SCOPE_SSLF, RB_LAST_FRAME).mipmaps;
|
||||
for (uint32_t v = 0; v < p_render_buffers->get_view_count(); v++) {
|
||||
for (uint32_t m = 0; m < mipmaps; m++) {
|
||||
RID source;
|
||||
if (m == 0) {
|
||||
source = p_render_buffers->get_internal_texture(v);
|
||||
} else {
|
||||
source = p_render_buffers->get_texture_slice(RB_SCOPE_SSLF, RB_LAST_FRAME, v, m - 1);
|
||||
}
|
||||
|
||||
RID dest = p_render_buffers->get_texture_slice(RB_SCOPE_SSLF, RB_LAST_FRAME, v, m);
|
||||
|
||||
Size2i source_size = RD::get_singleton()->texture_size(source);
|
||||
Size2i dest_size = RD::get_singleton()->texture_size(dest);
|
||||
|
||||
if (m == 0 && source_size == dest_size) {
|
||||
p_copy_effects.copy_to_rect(source, dest, Rect2i(Vector2i(), source_size));
|
||||
} else {
|
||||
p_copy_effects.make_mipmap(source, dest, dest_size);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SSEffects::~SSEffects() {
|
||||
{
|
||||
// Cleanup SS Reflections
|
||||
for (int v = 0; v < SSR_VARIATIONS; v++) {
|
||||
for (int i = 0; i < SCREEN_SPACE_REFLECTION_FILTER_MAX; i++) {
|
||||
ssr.pipelines[v][i].free();
|
||||
ssr_filter.pipelines[v][i].free();
|
||||
}
|
||||
|
||||
ssr_scale.pipelines[v].free();
|
||||
for (int i = 0; i < SCREEN_SPACE_REFLECTION_DOWNSAMPLE_MAX; i++) {
|
||||
ssr.downsample_pipelines[i].free();
|
||||
}
|
||||
for (int i = 0; i < SCREEN_SPACE_REFLECTION_HIZ_MAX; i++) {
|
||||
ssr.hiz_pipelines[i].free();
|
||||
}
|
||||
ssr.ssr_pipeline.free();
|
||||
ssr.filter_pipeline.free();
|
||||
ssr.resolve_pipeline.free();
|
||||
|
||||
ssr.shader.version_free(ssr.shader_version);
|
||||
ssr_filter.shader.version_free(ssr_filter.shader_version);
|
||||
ssr_scale.shader.version_free(ssr_scale.shader_version);
|
||||
ssr.downsample_shader.version_free(ssr.downsample_shader_version);
|
||||
ssr.hiz_shader.version_free(ssr.hiz_shader_version);
|
||||
ssr.ssr_shader.version_free(ssr.ssr_shader_version);
|
||||
ssr.filter_shader.version_free(ssr.filter_shader_version);
|
||||
ssr.resolve_shader.version_free(ssr.resolve_shader_version);
|
||||
|
||||
if (ssr.ubo.is_valid()) {
|
||||
RD::get_singleton()->free_rid(ssr.ubo);
|
||||
@@ -644,11 +710,6 @@ void SSEffects::ssil_allocate_buffers(Ref<RenderSceneBuffersRD> p_render_buffers
|
||||
RD::get_singleton()->texture_clear(final, Color(0, 0, 0, 0), 0, 1, 0, view_count);
|
||||
}
|
||||
|
||||
if (!p_render_buffers->has_texture(RB_SCOPE_SSIL, RB_LAST_FRAME)) {
|
||||
RID last_frame = p_render_buffers->create_texture(RB_SCOPE_SSIL, RB_LAST_FRAME, RD::DATA_FORMAT_R16G16B16A16_SFLOAT, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT, RD::TEXTURE_SAMPLES_1, p_settings.full_screen_size, 0, 6);
|
||||
RD::get_singleton()->texture_clear(last_frame, Color(0, 0, 0, 0), 0, 6, 0, view_count);
|
||||
}
|
||||
|
||||
// As we're not clearing these, and render buffers will return the cached texture if it already exists,
|
||||
// we don't first check has_texture here
|
||||
|
||||
@@ -668,7 +729,7 @@ void SSEffects::screen_space_indirect_lighting(Ref<RenderSceneBuffersRD> p_rende
|
||||
RD::get_singleton()->draw_command_begin_label("Process Screen-Space Indirect Lighting");
|
||||
|
||||
// Obtain our (cached) buffer slices for the view we are rendering.
|
||||
RID last_frame = p_render_buffers->get_texture_slice(RB_SCOPE_SSIL, RB_LAST_FRAME, p_view, 0, 1, 6);
|
||||
RID last_frame = p_render_buffers->get_texture_slice(RB_SCOPE_SSLF, RB_LAST_FRAME, p_view, 0, 1, 6);
|
||||
RID deinterleaved = p_render_buffers->get_texture_slice(RB_SCOPE_SSIL, RB_DEINTERLEAVED, p_view * 4, 0, 4, 1);
|
||||
RID deinterleaved_pong = p_render_buffers->get_texture_slice(RB_SCOPE_SSIL, RB_DEINTERLEAVED_PONG, 4 * p_view, 0, 4, 1);
|
||||
RID edges = p_render_buffers->get_texture_slice(RB_SCOPE_SSIL, RB_EDGES, 4 * p_view, 0, 4, 1);
|
||||
@@ -1364,43 +1425,56 @@ void SSEffects::generate_ssao(Ref<RenderSceneBuffersRD> p_render_buffers, SSAORe
|
||||
|
||||
/* Screen Space Reflection */
|
||||
|
||||
void SSEffects::ssr_set_roughness_quality(RS::EnvironmentSSRRoughnessQuality p_quality) {
|
||||
ssr_roughness_quality = p_quality;
|
||||
void SSEffects::ssr_set_half_size(bool p_half_size) {
|
||||
ssr_half_size = p_half_size;
|
||||
}
|
||||
|
||||
void SSEffects::ssr_allocate_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, SSRRenderBuffers &p_ssr_buffers, const RenderingDevice::DataFormat p_color_format) {
|
||||
if (p_ssr_buffers.roughness_quality != ssr_roughness_quality) {
|
||||
// Buffers will already be cleared if view count or viewport size has changed, also cleared them if we change roughness.
|
||||
void SSEffects::ssr_allocate_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, SSRRenderBuffers &p_ssr_buffers, const RD::DataFormat p_color_format) {
|
||||
if (p_ssr_buffers.half_size != ssr_half_size) {
|
||||
p_render_buffers->clear_context(RB_SCOPE_SSR);
|
||||
}
|
||||
|
||||
Size2i internal_size = p_render_buffers->get_internal_size();
|
||||
p_ssr_buffers.size = Size2i(internal_size.x / 2, internal_size.y / 2);
|
||||
p_ssr_buffers.roughness_quality = ssr_roughness_quality;
|
||||
Vector2i internal_size = p_render_buffers->get_internal_size();
|
||||
p_ssr_buffers.size = ssr_half_size ? (internal_size / 2) : internal_size;
|
||||
|
||||
// We are using barriers so we do not need to allocate textures for both views on anything but output...
|
||||
uint32_t cur_width = p_ssr_buffers.size.width;
|
||||
uint32_t cur_height = p_ssr_buffers.size.height;
|
||||
p_ssr_buffers.mipmaps = 1;
|
||||
|
||||
p_render_buffers->create_texture(RB_SCOPE_SSR, RB_DEPTH_SCALED, RD::DATA_FORMAT_R32_SFLOAT, RD::TEXTURE_USAGE_STORAGE_BIT, RD::TEXTURE_SAMPLES_1, p_ssr_buffers.size, 1);
|
||||
p_render_buffers->create_texture(RB_SCOPE_SSR, RB_NORMAL_SCALED, RD::DATA_FORMAT_R8G8B8A8_UNORM, RD::TEXTURE_USAGE_STORAGE_BIT, RD::TEXTURE_SAMPLES_1, p_ssr_buffers.size, 1);
|
||||
|
||||
if (ssr_roughness_quality != RS::ENV_SSR_ROUGHNESS_QUALITY_DISABLED && !p_render_buffers->has_texture(RB_SCOPE_SSR, RB_BLUR_RADIUS)) {
|
||||
p_render_buffers->create_texture(RB_SCOPE_SSR, RB_BLUR_RADIUS, RD::DATA_FORMAT_R8_UNORM, RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT, RD::TEXTURE_SAMPLES_1, p_ssr_buffers.size, 2); // 2 layers, for our two blur stages
|
||||
while (cur_width > 1 && cur_height > 1) {
|
||||
if (cur_width > 1) {
|
||||
cur_width /= 2;
|
||||
}
|
||||
if (cur_height > 1) {
|
||||
cur_height /= 2;
|
||||
}
|
||||
++p_ssr_buffers.mipmaps;
|
||||
}
|
||||
|
||||
p_render_buffers->create_texture(RB_SCOPE_SSR, RB_INTERMEDIATE, p_color_format, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT | RD::TEXTURE_USAGE_STORAGE_BIT, RD::TEXTURE_SAMPLES_1, p_ssr_buffers.size, 1);
|
||||
p_render_buffers->create_texture(RB_SCOPE_SSR, RB_OUTPUT, p_color_format, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT | RD::TEXTURE_USAGE_STORAGE_BIT, RD::TEXTURE_SAMPLES_1, p_ssr_buffers.size);
|
||||
p_ssr_buffers.half_size = ssr_half_size;
|
||||
|
||||
uint32_t view_count = p_render_buffers->get_view_count();
|
||||
|
||||
if (ssr_half_size) {
|
||||
p_render_buffers->create_texture(RB_SCOPE_SSR, RB_NORMAL_ROUGHNESS, RD::DATA_FORMAT_R8G8B8A8_UNORM, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT, RD::TEXTURE_SAMPLES_1, p_ssr_buffers.size, view_count);
|
||||
}
|
||||
|
||||
p_render_buffers->create_texture(RB_SCOPE_SSR, RB_HIZ, RD::DATA_FORMAT_R32_SFLOAT, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT, RD::TEXTURE_SAMPLES_1, p_ssr_buffers.size, view_count, p_ssr_buffers.mipmaps);
|
||||
p_render_buffers->create_texture(RB_SCOPE_SSR, RB_SSR, p_color_format, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT, RD::TEXTURE_SAMPLES_1, p_ssr_buffers.size, view_count, p_ssr_buffers.mipmaps);
|
||||
p_render_buffers->create_texture(RB_SCOPE_SSR, RB_MIP_LEVEL, RD::DATA_FORMAT_R8_UNORM, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT, RD::TEXTURE_SAMPLES_1, p_ssr_buffers.size, view_count);
|
||||
|
||||
if (ssr_half_size) {
|
||||
p_render_buffers->create_texture(RB_SCOPE_SSR, RB_FINAL, p_color_format, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT, RD::TEXTURE_SAMPLES_1, internal_size, view_count);
|
||||
}
|
||||
}
|
||||
|
||||
void SSEffects::screen_space_reflection(Ref<RenderSceneBuffersRD> p_render_buffers, SSRRenderBuffers &p_ssr_buffers, const RID *p_normal_roughness_slices, const RID *p_metallic_slices, int p_max_steps, float p_fade_in, float p_fade_out, float p_tolerance, const Projection *p_projections, const Vector3 *p_eye_offsets) {
|
||||
void SSEffects::screen_space_reflection(Ref<RenderSceneBuffersRD> p_render_buffers, SSRRenderBuffers &p_ssr_buffers, const RID *p_normal_roughness_slices, int p_max_steps, float p_fade_in, float p_fade_out, float p_tolerance, const Projection *p_projections, const Projection *p_reprojections, const Vector3 *p_eye_offsets, RendererRD::CopyEffects &p_copy_effects) {
|
||||
UniformSetCacheRD *uniform_set_cache = UniformSetCacheRD::get_singleton();
|
||||
ERR_FAIL_NULL(uniform_set_cache);
|
||||
MaterialStorage *material_storage = MaterialStorage::get_singleton();
|
||||
ERR_FAIL_NULL(material_storage);
|
||||
|
||||
uint32_t view_count = p_render_buffers->get_view_count();
|
||||
|
||||
RID default_sampler = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
|
||||
|
||||
{
|
||||
// Store some scene data in a UBO, in the near future we will use a UBO shared with other shaders
|
||||
ScreenSpaceReflectionSceneData scene_data;
|
||||
@@ -1409,227 +1483,252 @@ void SSEffects::screen_space_reflection(Ref<RenderSceneBuffersRD> p_render_buffe
|
||||
ssr.ubo = RD::get_singleton()->uniform_buffer_create(sizeof(ScreenSpaceReflectionSceneData));
|
||||
}
|
||||
|
||||
Projection correction;
|
||||
correction.set_depth_correction(true);
|
||||
|
||||
for (uint32_t v = 0; v < view_count; v++) {
|
||||
store_camera(p_projections[v], scene_data.projection[v]);
|
||||
store_camera(p_projections[v].inverse(), scene_data.inv_projection[v]);
|
||||
Projection projection = correction * p_projections[v];
|
||||
|
||||
store_camera(projection, scene_data.projection[v]);
|
||||
store_camera(projection.inverse(), scene_data.inv_projection[v]);
|
||||
store_camera(p_reprojections[v], scene_data.reprojection[v]);
|
||||
scene_data.eye_offset[v][0] = p_eye_offsets[v].x;
|
||||
scene_data.eye_offset[v][1] = p_eye_offsets[v].y;
|
||||
scene_data.eye_offset[v][2] = p_eye_offsets[v].z;
|
||||
scene_data.eye_offset[v][3] = 0.0;
|
||||
scene_data.eye_offset[v][3] = 0.0f;
|
||||
}
|
||||
|
||||
RD::get_singleton()->buffer_update(ssr.ubo, 0, sizeof(ScreenSpaceReflectionSceneData), &scene_data);
|
||||
}
|
||||
|
||||
uint32_t pipeline_specialization = 0;
|
||||
if (view_count > 1) {
|
||||
pipeline_specialization |= SSR_MULTIVIEW;
|
||||
}
|
||||
RID linear_sampler = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
|
||||
RID nearest_sampler = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
|
||||
|
||||
RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
|
||||
|
||||
for (uint32_t v = 0; v < view_count; v++) {
|
||||
// get buffers we need to use for this view
|
||||
RID diffuse_slice = p_render_buffers->get_internal_texture(v);
|
||||
RID depth_slice = p_render_buffers->get_depth_texture(v);
|
||||
RID depth_scaled = p_render_buffers->get_texture(RB_SCOPE_SSR, RB_DEPTH_SCALED);
|
||||
RID normal_scaled = p_render_buffers->get_texture(RB_SCOPE_SSR, RB_NORMAL_SCALED);
|
||||
RID intermediate = p_render_buffers->get_texture(RB_SCOPE_SSR, RB_INTERMEDIATE);
|
||||
RID output = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_OUTPUT, v, 0);
|
||||
|
||||
RID blur_radius[2];
|
||||
if (ssr_roughness_quality != RS::ENV_SSR_ROUGHNESS_QUALITY_DISABLED) {
|
||||
blur_radius[0] = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_BLUR_RADIUS, 0, 0);
|
||||
blur_radius[1] = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_BLUR_RADIUS, 1, 0);
|
||||
}
|
||||
|
||||
{
|
||||
char label[16];
|
||||
int len = snprintf(label, sizeof(label), "SSR View %d", v);
|
||||
RD::get_singleton()->draw_command_begin_label(Span<char>(label, len));
|
||||
}
|
||||
|
||||
{ //scale color and depth to half
|
||||
RD::get_singleton()->draw_command_begin_label("SSR Scale");
|
||||
|
||||
ScreenSpaceReflectionScalePushConstant push_constant;
|
||||
push_constant.view_index = v;
|
||||
push_constant.camera_z_far = p_projections[v].get_z_far();
|
||||
push_constant.camera_z_near = p_projections[v].get_z_near();
|
||||
push_constant.orthogonal = p_projections[v].is_orthogonal();
|
||||
push_constant.filter = false; // Enabling causes artifacts.
|
||||
push_constant.screen_size[0] = p_ssr_buffers.size.x;
|
||||
push_constant.screen_size[1] = p_ssr_buffers.size.y;
|
||||
|
||||
RID shader = ssr_scale.shader.version_get_shader(ssr_scale.shader_version, 0);
|
||||
|
||||
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, ssr_scale.pipelines[pipeline_specialization].get_rid());
|
||||
|
||||
RD::Uniform u_diffuse(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 0, Vector<RID>({ default_sampler, diffuse_slice }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 0, u_diffuse), 0);
|
||||
|
||||
RD::Uniform u_depth(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 0, Vector<RID>({ default_sampler, depth_slice }));
|
||||
RD::Uniform u_normal_roughness(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 1, Vector<RID>({ default_sampler, p_normal_roughness_slices[v] }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 1, u_depth, u_normal_roughness), 1);
|
||||
|
||||
RD::Uniform u_intermediate(RD::UNIFORM_TYPE_IMAGE, 0, Vector<RID>({ intermediate }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 2, u_intermediate), 2);
|
||||
|
||||
RD::Uniform u_scale_depth(RD::UNIFORM_TYPE_IMAGE, 0, Vector<RID>({ depth_scaled }));
|
||||
RD::Uniform u_scale_normal(RD::UNIFORM_TYPE_IMAGE, 1, Vector<RID>({ normal_scaled }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 3, u_scale_depth, u_scale_normal), 3);
|
||||
|
||||
RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(ScreenSpaceReflectionScalePushConstant));
|
||||
RD::get_singleton()->compute_list_dispatch_threads(compute_list, p_ssr_buffers.size.width, p_ssr_buffers.size.height, 1);
|
||||
|
||||
RD::get_singleton()->compute_list_add_barrier(compute_list);
|
||||
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
}
|
||||
|
||||
{
|
||||
RD::get_singleton()->draw_command_begin_label("SSR Main");
|
||||
|
||||
ScreenSpaceReflectionPushConstant push_constant;
|
||||
push_constant.view_index = v;
|
||||
push_constant.camera_z_far = p_projections[v].get_z_far();
|
||||
push_constant.camera_z_near = p_projections[v].get_z_near();
|
||||
push_constant.orthogonal = p_projections[v].is_orthogonal();
|
||||
push_constant.screen_size[0] = p_ssr_buffers.size.x;
|
||||
push_constant.screen_size[1] = p_ssr_buffers.size.y;
|
||||
push_constant.curve_fade_in = p_fade_in;
|
||||
push_constant.distance_fade = p_fade_out;
|
||||
push_constant.num_steps = p_max_steps;
|
||||
push_constant.depth_tolerance = p_tolerance;
|
||||
push_constant.use_half_res = true;
|
||||
push_constant.proj_info[0] = -2.0f / (p_ssr_buffers.size.width * p_projections[v].columns[0][0]);
|
||||
push_constant.proj_info[1] = -2.0f / (p_ssr_buffers.size.height * p_projections[v].columns[1][1]);
|
||||
push_constant.proj_info[2] = (1.0f - p_projections[v].columns[0][2]) / p_projections[v].columns[0][0];
|
||||
push_constant.proj_info[3] = (1.0f + p_projections[v].columns[1][2]) / p_projections[v].columns[1][1];
|
||||
|
||||
ScreenSpaceReflectionMode mode = (ssr_roughness_quality != RS::ENV_SSR_ROUGHNESS_QUALITY_DISABLED) ? SCREEN_SPACE_REFLECTION_ROUGH : SCREEN_SPACE_REFLECTION_NORMAL;
|
||||
RID shader = ssr.shader.version_get_shader(ssr.shader_version, mode);
|
||||
|
||||
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, ssr.pipelines[pipeline_specialization][mode].get_rid());
|
||||
|
||||
RD::Uniform u_scene_data(RD::UNIFORM_TYPE_UNIFORM_BUFFER, 0, ssr.ubo);
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 4, u_scene_data), 4);
|
||||
|
||||
// read from intermediate
|
||||
RD::Uniform u_intermediate(RD::UNIFORM_TYPE_IMAGE, 0, Vector<RID>({ intermediate }));
|
||||
RD::Uniform u_scale_depth(RD::UNIFORM_TYPE_IMAGE, 1, Vector<RID>({ depth_scaled }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 0, u_intermediate, u_scale_depth), 0);
|
||||
|
||||
if (ssr_roughness_quality != RS::ENV_SSR_ROUGHNESS_QUALITY_DISABLED) {
|
||||
// write to output and blur radius
|
||||
RD::Uniform u_output(RD::UNIFORM_TYPE_IMAGE, 0, Vector<RID>({ output }));
|
||||
RD::Uniform u_blur_radius(RD::UNIFORM_TYPE_IMAGE, 1, Vector<RID>({ blur_radius[0] }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 1, u_output, u_blur_radius), 1);
|
||||
} else {
|
||||
// We are only writing output
|
||||
RD::Uniform u_output(RD::UNIFORM_TYPE_IMAGE, 0, Vector<RID>({ output }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 1, u_output), 1);
|
||||
}
|
||||
|
||||
RD::Uniform u_scale_normal(RD::UNIFORM_TYPE_IMAGE, 0, Vector<RID>({ normal_scaled }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 2, u_scale_normal), 2);
|
||||
|
||||
RD::Uniform u_metallic(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 0, Vector<RID>({ default_sampler, p_metallic_slices[v] }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 3, u_metallic), 3);
|
||||
|
||||
RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(ScreenSpaceReflectionPushConstant));
|
||||
RD::get_singleton()->compute_list_dispatch_threads(compute_list, p_ssr_buffers.size.width, p_ssr_buffers.size.height, 1);
|
||||
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
}
|
||||
|
||||
if (ssr_roughness_quality != RS::ENV_SSR_ROUGHNESS_QUALITY_DISABLED) {
|
||||
RD::get_singleton()->draw_command_begin_label("SSR Roughness Filter");
|
||||
//blur
|
||||
|
||||
RD::get_singleton()->compute_list_add_barrier(compute_list);
|
||||
|
||||
ScreenSpaceReflectionFilterPushConstant push_constant;
|
||||
push_constant.view_index = v;
|
||||
push_constant.orthogonal = p_projections[v].is_orthogonal();
|
||||
push_constant.edge_tolerance = Math::sin(Math::deg_to_rad(15.0));
|
||||
push_constant.proj_info[0] = -2.0f / (p_ssr_buffers.size.width * p_projections[v].columns[0][0]);
|
||||
push_constant.proj_info[1] = -2.0f / (p_ssr_buffers.size.height * p_projections[v].columns[1][1]);
|
||||
push_constant.proj_info[2] = (1.0f - p_projections[v].columns[0][2]) / p_projections[v].columns[0][0];
|
||||
push_constant.proj_info[3] = (1.0f + p_projections[v].columns[1][2]) / p_projections[v].columns[1][1];
|
||||
push_constant.vertical = 0;
|
||||
if (ssr_roughness_quality == RS::ENV_SSR_ROUGHNESS_QUALITY_LOW) {
|
||||
push_constant.steps = p_max_steps / 3;
|
||||
push_constant.increment = 3;
|
||||
} else if (ssr_roughness_quality == RS::ENV_SSR_ROUGHNESS_QUALITY_MEDIUM) {
|
||||
push_constant.steps = p_max_steps / 2;
|
||||
push_constant.increment = 2;
|
||||
} else {
|
||||
push_constant.steps = p_max_steps;
|
||||
push_constant.increment = 1;
|
||||
}
|
||||
if (ssr_half_size) {
|
||||
RD::get_singleton()->draw_command_begin_label("SSR Downsample");
|
||||
|
||||
for (uint32_t v = 0; v < view_count; v++) {
|
||||
ScreenSpaceReflectionDownsamplePushConstant push_constant;
|
||||
push_constant.screen_size[0] = p_ssr_buffers.size.width;
|
||||
push_constant.screen_size[1] = p_ssr_buffers.size.height;
|
||||
|
||||
// Horizontal pass
|
||||
RID source_depth_texture = p_render_buffers->get_depth_texture(v);
|
||||
RID dest_depth_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_HIZ, v, 0);
|
||||
RID dest_normal_roughness_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_NORMAL_ROUGHNESS, v, 0);
|
||||
|
||||
SSRReflectionMode mode = SCREEN_SPACE_REFLECTION_FILTER_HORIZONTAL;
|
||||
Size2i parent_size = RD::get_singleton()->texture_size(source_depth_texture);
|
||||
bool is_width_odd = (parent_size.width % 2) != 0;
|
||||
bool is_height_odd = (parent_size.height % 2) != 0;
|
||||
|
||||
RID shader = ssr_filter.shader.version_get_shader(ssr_filter.shader_version, mode);
|
||||
|
||||
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, ssr_filter.pipelines[pipeline_specialization][mode].get_rid());
|
||||
|
||||
RD::Uniform u_output(RD::UNIFORM_TYPE_IMAGE, 0, Vector<RID>({ output }));
|
||||
RD::Uniform u_blur_radius(RD::UNIFORM_TYPE_IMAGE, 1, Vector<RID>({ blur_radius[0] }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 0, u_output, u_blur_radius), 0);
|
||||
|
||||
RD::Uniform u_scale_normal(RD::UNIFORM_TYPE_IMAGE, 0, Vector<RID>({ normal_scaled }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 1, u_scale_normal), 1);
|
||||
|
||||
RD::Uniform u_intermediate(RD::UNIFORM_TYPE_IMAGE, 0, Vector<RID>({ intermediate }));
|
||||
RD::Uniform u_blur_radius2(RD::UNIFORM_TYPE_IMAGE, 1, Vector<RID>({ blur_radius[1] }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 2, u_intermediate, u_blur_radius2), 2);
|
||||
|
||||
RD::Uniform u_scale_depth(RD::UNIFORM_TYPE_IMAGE, 0, Vector<RID>({ depth_scaled }));
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 3, u_scale_depth), 3);
|
||||
|
||||
RD::Uniform u_scene_data(RD::UNIFORM_TYPE_UNIFORM_BUFFER, 0, ssr.ubo);
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 4, u_scene_data), 4);
|
||||
|
||||
RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(ScreenSpaceReflectionFilterPushConstant));
|
||||
RD::get_singleton()->compute_list_dispatch_threads(compute_list, p_ssr_buffers.size.width, p_ssr_buffers.size.height, 1);
|
||||
RD::get_singleton()->compute_list_add_barrier(compute_list);
|
||||
|
||||
// Vertical pass
|
||||
|
||||
mode = SCREEN_SPACE_REFLECTION_FILTER_VERTICAL;
|
||||
shader = ssr_filter.shader.version_get_shader(ssr_filter.shader_version, mode);
|
||||
|
||||
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, ssr_filter.pipelines[pipeline_specialization][mode].get_rid());
|
||||
|
||||
push_constant.vertical = 1;
|
||||
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 0, u_intermediate, u_blur_radius2), 0);
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 1, u_scale_normal), 1);
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 2, u_output), 2);
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 3, u_scale_depth), 3);
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 4, u_scene_data), 4);
|
||||
|
||||
RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(ScreenSpaceReflectionFilterPushConstant));
|
||||
RD::get_singleton()->compute_list_dispatch_threads(compute_list, p_ssr_buffers.size.width, p_ssr_buffers.size.height, 1);
|
||||
|
||||
if (v != view_count - 1) {
|
||||
RD::get_singleton()->compute_list_add_barrier(compute_list);
|
||||
int32_t downsample_mode;
|
||||
if (is_width_odd && is_height_odd) {
|
||||
downsample_mode = SCREEN_SPACE_REFLECTION_DOWNSAMPLE_ODD_WIDTH_AND_HEIGHT;
|
||||
} else if (is_width_odd) {
|
||||
downsample_mode = SCREEN_SPACE_REFLECTION_DOWNSAMPLE_ODD_WIDTH;
|
||||
} else if (is_height_odd) {
|
||||
downsample_mode = SCREEN_SPACE_REFLECTION_DOWNSAMPLE_ODD_HEIGHT;
|
||||
} else {
|
||||
downsample_mode = SCREEN_SPACE_REFLECTION_DOWNSAMPLE_DEFAULT;
|
||||
}
|
||||
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
RID downsample_shader = ssr.downsample_shader.version_get_shader(ssr.downsample_shader_version, downsample_mode);
|
||||
|
||||
RD::Uniform u_source_depth(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 0, Vector<RID>{ nearest_sampler, source_depth_texture });
|
||||
RD::Uniform u_source_normal_roughness(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 1, Vector<RID>{ nearest_sampler, p_normal_roughness_slices[v] });
|
||||
RD::Uniform u_dest_depth(RD::UNIFORM_TYPE_IMAGE, 2, dest_depth_texture);
|
||||
RD::Uniform u_dest_normal_roughness(RD::UNIFORM_TYPE_IMAGE, 3, dest_normal_roughness_texture);
|
||||
|
||||
RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
|
||||
|
||||
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, ssr.downsample_pipelines[downsample_mode].get_rid());
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(downsample_shader, 0, u_source_depth, u_source_normal_roughness, u_dest_depth, u_dest_normal_roughness), 0);
|
||||
RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(push_constant));
|
||||
RD::get_singleton()->compute_list_dispatch_threads(compute_list, push_constant.screen_size[0], push_constant.screen_size[1], 1);
|
||||
|
||||
RD::get_singleton()->compute_list_end();
|
||||
}
|
||||
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
} else {
|
||||
RD::get_singleton()->draw_command_begin_label("SSR Copy Depth");
|
||||
|
||||
for (uint32_t v = 0; v < view_count; v++) {
|
||||
RID src_texture = p_render_buffers->get_depth_texture(v);
|
||||
RID dest_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_HIZ, v, 0);
|
||||
p_copy_effects.copy_depth_to_rect(src_texture, dest_texture, Rect2i(Vector2i(), p_ssr_buffers.size));
|
||||
}
|
||||
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
}
|
||||
|
||||
RD::get_singleton()->compute_list_end();
|
||||
RD::get_singleton()->draw_command_begin_label("SSR HI-Z");
|
||||
|
||||
for (uint32_t v = 0; v < view_count; v++) {
|
||||
for (uint32_t m = 1; m < p_ssr_buffers.mipmaps; m++) {
|
||||
ScreenSpaceReflectionHizPushConstant push_constant;
|
||||
push_constant.screen_size[0] = MAX(1, p_ssr_buffers.size.width >> m);
|
||||
push_constant.screen_size[1] = MAX(1, p_ssr_buffers.size.height >> m);
|
||||
|
||||
RID source;
|
||||
|
||||
if (!ssr_half_size && m == 1) { // Reuse the depth texture to not create a dependency on the previous depth copy pass.
|
||||
source = p_render_buffers->get_depth_texture(v);
|
||||
} else {
|
||||
source = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_HIZ, v, m - 1);
|
||||
}
|
||||
|
||||
RID dest = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_HIZ, v, m);
|
||||
|
||||
Size2i parent_size = RD::get_singleton()->texture_size(source);
|
||||
bool is_width_odd = (parent_size.width % 2) != 0;
|
||||
bool is_height_odd = (parent_size.height % 2) != 0;
|
||||
|
||||
int32_t hiz_mode;
|
||||
if (is_width_odd && is_height_odd) {
|
||||
hiz_mode = SCREEN_SPACE_REFLECTION_HIZ_ODD_WIDTH_AND_HEIGHT;
|
||||
} else if (is_width_odd) {
|
||||
hiz_mode = SCREEN_SPACE_REFLECTION_HIZ_ODD_WIDTH;
|
||||
} else if (is_height_odd) {
|
||||
hiz_mode = SCREEN_SPACE_REFLECTION_HIZ_ODD_HEIGHT;
|
||||
} else {
|
||||
hiz_mode = SCREEN_SPACE_REFLECTION_HIZ_DEFAULT;
|
||||
}
|
||||
|
||||
RID hiz_shader = ssr.hiz_shader.version_get_shader(ssr.hiz_shader_version, hiz_mode);
|
||||
|
||||
RD::Uniform u_source(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 0, Vector<RID>{ nearest_sampler, source });
|
||||
RD::Uniform u_dest(RD::UNIFORM_TYPE_IMAGE, 1, dest);
|
||||
|
||||
RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
|
||||
|
||||
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, ssr.hiz_pipelines[hiz_mode].get_rid());
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(hiz_shader, 0, u_source, u_dest), 0);
|
||||
RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(push_constant));
|
||||
RD::get_singleton()->compute_list_dispatch_threads(compute_list, push_constant.screen_size[0], push_constant.screen_size[1], 1);
|
||||
|
||||
RD::get_singleton()->compute_list_end();
|
||||
}
|
||||
}
|
||||
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
|
||||
RD::get_singleton()->draw_command_begin_label("SSR Main");
|
||||
|
||||
RID ssr_shader = ssr.ssr_shader.version_get_shader(ssr.ssr_shader_version, 0);
|
||||
|
||||
for (uint32_t v = 0; v < view_count; v++) {
|
||||
RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
|
||||
|
||||
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, ssr.ssr_pipeline.get_rid());
|
||||
|
||||
ScreenSpaceReflectionPushConstant push_constant;
|
||||
push_constant.screen_size[0] = p_ssr_buffers.size.width;
|
||||
push_constant.screen_size[1] = p_ssr_buffers.size.height;
|
||||
push_constant.mipmaps = p_ssr_buffers.mipmaps;
|
||||
push_constant.num_steps = p_max_steps;
|
||||
push_constant.curve_fade_in = p_fade_in;
|
||||
push_constant.distance_fade = p_fade_out;
|
||||
push_constant.depth_tolerance = p_tolerance;
|
||||
push_constant.orthogonal = p_projections[v].is_orthogonal();
|
||||
push_constant.view_index = v;
|
||||
|
||||
RID last_frame_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSLF, RB_LAST_FRAME, v, 0);
|
||||
if (ssr_half_size && RD::get_singleton()->texture_size(last_frame_texture) != p_ssr_buffers.size) {
|
||||
// SSIL is likely also enabled. The texture we need is in the second mipmap in this case.
|
||||
last_frame_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSLF, RB_LAST_FRAME, v, 1);
|
||||
}
|
||||
|
||||
RID hiz_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_HIZ, v, 0, 1, p_ssr_buffers.mipmaps);
|
||||
RID normal_roughness_texture = ssr_half_size ? p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_NORMAL_ROUGHNESS, v, 0) : p_normal_roughness_slices[v];
|
||||
RID ssr_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_SSR, v, 0);
|
||||
RID mip_level_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_MIP_LEVEL, v, 0);
|
||||
|
||||
RD::Uniform u_last_frame(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 0, Vector<RID>{ linear_sampler, last_frame_texture });
|
||||
RD::Uniform u_hiz(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 1, Vector<RID>{ nearest_sampler, hiz_texture });
|
||||
RD::Uniform u_normal_roughness(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 2, Vector<RID>{ nearest_sampler, normal_roughness_texture });
|
||||
RD::Uniform u_ssr(RD::UNIFORM_TYPE_IMAGE, 3, ssr_texture);
|
||||
RD::Uniform u_mip_level(RD::UNIFORM_TYPE_IMAGE, 4, mip_level_texture);
|
||||
RD::Uniform u_scene_data(RD::UNIFORM_TYPE_UNIFORM_BUFFER, 5, ssr.ubo);
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(ssr_shader, 0, u_last_frame, u_hiz, u_normal_roughness, u_ssr, u_mip_level, u_scene_data), 0);
|
||||
|
||||
RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(push_constant));
|
||||
RD::get_singleton()->compute_list_dispatch_threads(compute_list, p_ssr_buffers.size.width, p_ssr_buffers.size.height, 1);
|
||||
|
||||
RD::get_singleton()->compute_list_end();
|
||||
}
|
||||
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
|
||||
RD::get_singleton()->draw_command_begin_label("SSR Roughness Filter");
|
||||
|
||||
RID filter_shader = ssr.filter_shader.version_get_shader(ssr.filter_shader_version, 0);
|
||||
|
||||
for (uint32_t v = 0; v < view_count; v++) {
|
||||
for (uint32_t m = 1; m < p_ssr_buffers.mipmaps; m++) {
|
||||
ScreenSpaceReflectionFilterPushConstant push_constant;
|
||||
push_constant.screen_size[0] = MAX(1, p_ssr_buffers.size.width >> m);
|
||||
push_constant.screen_size[1] = MAX(1, p_ssr_buffers.size.height >> m);
|
||||
push_constant.mip_level = m;
|
||||
|
||||
RID source = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_SSR, v, m - 1);
|
||||
RID dest = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_SSR, v, m);
|
||||
|
||||
RD::Uniform u_source(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 0, Vector<RID>{ linear_sampler, source });
|
||||
RD::Uniform u_dest(RD::UNIFORM_TYPE_IMAGE, 1, dest);
|
||||
|
||||
RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
|
||||
|
||||
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, ssr.filter_pipeline.get_rid());
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(filter_shader, 0, u_source, u_dest), 0);
|
||||
RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(push_constant));
|
||||
RD::get_singleton()->compute_list_dispatch_threads(compute_list, push_constant.screen_size[0], push_constant.screen_size[1], 1);
|
||||
|
||||
RD::get_singleton()->compute_list_end();
|
||||
}
|
||||
}
|
||||
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
|
||||
if (ssr_half_size) {
|
||||
RD::get_singleton()->draw_command_begin_label("SSR Resolve");
|
||||
|
||||
RID resolve_shader = ssr.resolve_shader.version_get_shader(ssr.resolve_shader_version, 0);
|
||||
|
||||
for (uint32_t v = 0; v < view_count; v++) {
|
||||
RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
|
||||
|
||||
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, ssr.resolve_pipeline.get_rid());
|
||||
|
||||
Vector2i internal_size = p_render_buffers->get_internal_size();
|
||||
|
||||
ScreenSpaceReflectionResolvePushConstant push_constant;
|
||||
push_constant.screen_size[0] = internal_size.x;
|
||||
push_constant.screen_size[1] = internal_size.y;
|
||||
|
||||
RID depth_texture = p_render_buffers->get_depth_texture(v);
|
||||
RID depth_half_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_HIZ, v, 0);
|
||||
RID normal_roughness_half_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_NORMAL_ROUGHNESS, v, 0);
|
||||
RID ssr_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_SSR, v, 0, 1, p_ssr_buffers.mipmaps);
|
||||
RID mip_level_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_MIP_LEVEL, v, 0);
|
||||
RID output_texture = p_render_buffers->get_texture_slice(RB_SCOPE_SSR, RB_FINAL, v, 0);
|
||||
|
||||
RD::Uniform u_depth(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 0, Vector<RID>{ nearest_sampler, depth_texture });
|
||||
RD::Uniform u_normal_roughness(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 1, Vector<RID>{ nearest_sampler, p_normal_roughness_slices[v] });
|
||||
RD::Uniform u_depth_half(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 2, Vector<RID>{ nearest_sampler, depth_half_texture });
|
||||
RD::Uniform u_normal_roughness_half(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 3, Vector<RID>{ nearest_sampler, normal_roughness_half_texture });
|
||||
RD::Uniform u_ssr(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 4, Vector<RID>{ linear_sampler, ssr_texture });
|
||||
RD::Uniform u_mip_level(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 5, Vector<RID>{ nearest_sampler, mip_level_texture });
|
||||
RD::Uniform u_output(RD::UNIFORM_TYPE_IMAGE, 6, output_texture);
|
||||
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(resolve_shader, 0, u_depth, u_normal_roughness, u_depth_half, u_normal_roughness_half, u_ssr, u_mip_level, u_output), 0);
|
||||
|
||||
RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(push_constant));
|
||||
RD::get_singleton()->compute_list_dispatch_threads(compute_list, internal_size.width, internal_size.height, 1);
|
||||
|
||||
RD::get_singleton()->compute_list_end();
|
||||
}
|
||||
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
}
|
||||
}
|
||||
|
||||
/* Subsurface scattering */
|
||||
|
||||
Reference in New Issue
Block a user