feat: updated engine version to 4.4-rc1
This commit is contained in:
Sara
parent
ee00efde1f
commit
21ba8e33af
5459 changed files with 1128836 additions and 198305 deletions
|
|
@ -1,4 +1,5 @@
|
|||
#!/usr/bin/env python
|
||||
from misc.utility.scons_hints import *
|
||||
|
||||
Import("env")
|
||||
|
||||
|
|
|
|||
|
|
@ -157,7 +157,7 @@ RendererRD::MaterialStorage::ShaderData *Fog::_create_fog_shader_func() {
|
|||
|
||||
RendererRD::MaterialStorage::ShaderData *Fog::_create_fog_shader_funcs() {
|
||||
return Fog::get_singleton()->_create_fog_shader_func();
|
||||
};
|
||||
}
|
||||
|
||||
RendererRD::MaterialStorage::MaterialData *Fog::_create_fog_material_func(FogShaderData *p_shader) {
|
||||
FogMaterialData *material_data = memnew(FogMaterialData);
|
||||
|
|
@ -168,7 +168,7 @@ RendererRD::MaterialStorage::MaterialData *Fog::_create_fog_material_func(FogSha
|
|||
|
||||
RendererRD::MaterialStorage::MaterialData *Fog::_create_fog_material_funcs(RendererRD::MaterialStorage::ShaderData *p_shader) {
|
||||
return Fog::get_singleton()->_create_fog_material_func(static_cast<FogShaderData *>(p_shader));
|
||||
};
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// FOG VOLUMES INSTANCE
|
||||
|
|
@ -264,7 +264,7 @@ ALBEDO = vec3(1.0);
|
|||
uniforms.push_back(u);
|
||||
}
|
||||
|
||||
uniforms.append_array(material_storage->samplers_rd_get_default().get_uniforms(SAMPLERS_BINDING_FIRST_INDEX));
|
||||
material_storage->samplers_rd_get_default().append_uniforms(uniforms, SAMPLERS_BINDING_FIRST_INDEX);
|
||||
|
||||
volumetric_fog.base_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.default_shader_rd, VolumetricFogShader::FogSet::FOG_SET_BASE);
|
||||
}
|
||||
|
|
@ -622,6 +622,7 @@ void Fog::volumetric_fog_update(const VolumetricFogSettings &p_settings, const P
|
|||
|
||||
RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
|
||||
bool any_uses_time = false;
|
||||
Vector3 cam_position = p_cam_transform.get_origin();
|
||||
|
||||
for (int i = 0; i < (int)p_fog_volumes.size(); i++) {
|
||||
FogVolumeInstance *fog_volume_instance = fog_volume_instance_owner.get_or_null(p_fog_volumes[i]);
|
||||
|
|
@ -652,41 +653,68 @@ void Fog::volumetric_fog_update(const VolumetricFogSettings &p_settings, const P
|
|||
|
||||
any_uses_time |= shader_data->uses_time;
|
||||
|
||||
Vector3i min;
|
||||
Vector3i max;
|
||||
Vector3i froxel_min;
|
||||
Vector3i froxel_max;
|
||||
Vector3i kernel_size;
|
||||
|
||||
Vector3 position = fog_volume_instance->transform.get_origin();
|
||||
Vector3 fog_position = fog_volume_instance->transform.get_origin();
|
||||
RS::FogVolumeShape volume_type = RendererRD::Fog::get_singleton()->fog_volume_get_shape(fog_volume);
|
||||
Vector3 extents = RendererRD::Fog::get_singleton()->fog_volume_get_size(fog_volume) / 2;
|
||||
|
||||
if (volume_type != RS::FOG_VOLUME_SHAPE_WORLD) {
|
||||
// Local fog volume.
|
||||
Vector3i points[8];
|
||||
Vector3 fog_size = Vector3(fog->width, fog->height, fog->depth);
|
||||
float volumetric_fog_detail_spread = RendererSceneRenderRD::get_singleton()->environment_get_volumetric_fog_detail_spread(p_settings.env);
|
||||
points[0] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, volumetric_fog_detail_spread, fog_size, p_cam_transform);
|
||||
points[1] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, volumetric_fog_detail_spread, fog_size, p_cam_transform);
|
||||
points[2] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, -extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, volumetric_fog_detail_spread, fog_size, p_cam_transform);
|
||||
points[3] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, -extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, volumetric_fog_detail_spread, fog_size, p_cam_transform);
|
||||
points[4] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, volumetric_fog_detail_spread, fog_size, p_cam_transform);
|
||||
points[5] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, volumetric_fog_detail_spread, fog_size, p_cam_transform);
|
||||
points[6] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, -extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, volumetric_fog_detail_spread, fog_size, p_cam_transform);
|
||||
points[7] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, -extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, volumetric_fog_detail_spread, fog_size, p_cam_transform);
|
||||
|
||||
min = Vector3i(int32_t(fog->width) - 1, int32_t(fog->height) - 1, int32_t(fog->depth) - 1);
|
||||
max = Vector3i(1, 1, 1);
|
||||
|
||||
Vector3 corners[8]{
|
||||
fog_volume_instance->transform.xform(Vector3(extents.x, extents.y, extents.z)),
|
||||
fog_volume_instance->transform.xform(Vector3(-extents.x, extents.y, extents.z)),
|
||||
fog_volume_instance->transform.xform(Vector3(extents.x, -extents.y, extents.z)),
|
||||
fog_volume_instance->transform.xform(Vector3(-extents.x, -extents.y, extents.z)),
|
||||
fog_volume_instance->transform.xform(Vector3(extents.x, extents.y, -extents.z)),
|
||||
fog_volume_instance->transform.xform(Vector3(-extents.x, extents.y, -extents.z)),
|
||||
fog_volume_instance->transform.xform(Vector3(extents.x, -extents.y, -extents.z)),
|
||||
fog_volume_instance->transform.xform(Vector3(-extents.x, -extents.y, -extents.z))
|
||||
};
|
||||
Vector3i froxels[8];
|
||||
Vector3 corner_min = corners[0];
|
||||
Vector3 corner_max = corners[0];
|
||||
for (int j = 0; j < 8; j++) {
|
||||
min = min.min(points[j]);
|
||||
max = max.max(points[j]);
|
||||
froxels[j] = _point_get_position_in_froxel_volume(corners[j], fog_end, fog_near_size, fog_far_size, volumetric_fog_detail_spread, fog_size, p_cam_transform);
|
||||
corner_min = corner_min.min(corners[j]);
|
||||
corner_max = corner_max.max(corners[j]);
|
||||
}
|
||||
|
||||
kernel_size = max - min;
|
||||
froxel_min = Vector3i(int32_t(fog->width) - 1, int32_t(fog->height) - 1, int32_t(fog->depth) - 1);
|
||||
froxel_max = Vector3i(1, 1, 1);
|
||||
|
||||
// Tracking just the corners of the fog volume can result in missing some fog:
|
||||
// when the camera's near plane is inside the fog, we must always consider the entire screen
|
||||
Vector3 near_plane_corner(frustum_near_size.x, frustum_near_size.y, z_near);
|
||||
float expand = near_plane_corner.length();
|
||||
if (cam_position.x > (corner_min.x - expand) && cam_position.x < (corner_max.x + expand) &&
|
||||
cam_position.y > (corner_min.y - expand) && cam_position.y < (corner_max.y + expand) &&
|
||||
cam_position.z > (corner_min.z - expand) && cam_position.z < (corner_max.z + expand)) {
|
||||
froxel_min.x = 0;
|
||||
froxel_min.y = 0;
|
||||
froxel_min.z = 0;
|
||||
froxel_max.x = int32_t(fog->width);
|
||||
froxel_max.y = int32_t(fog->height);
|
||||
for (int j = 0; j < 8; j++) {
|
||||
froxel_max.z = MAX(froxel_max.z, froxels[j].z);
|
||||
}
|
||||
} else {
|
||||
// Camera is guaranteed to be outside the fog volume
|
||||
for (int j = 0; j < 8; j++) {
|
||||
froxel_min = froxel_min.min(froxels[j]);
|
||||
froxel_max = froxel_max.max(froxels[j]);
|
||||
}
|
||||
}
|
||||
|
||||
kernel_size = froxel_max - froxel_min;
|
||||
} else {
|
||||
// Volume type global runs on all cells
|
||||
extents = Vector3(fog->width, fog->height, fog->depth);
|
||||
min = Vector3i(0, 0, 0);
|
||||
froxel_min = Vector3i(0, 0, 0);
|
||||
kernel_size = Vector3i(int32_t(fog->width), int32_t(fog->height), int32_t(fog->depth));
|
||||
}
|
||||
|
||||
|
|
@ -695,15 +723,15 @@ void Fog::volumetric_fog_update(const VolumetricFogSettings &p_settings, const P
|
|||
}
|
||||
|
||||
VolumetricFogShader::FogPushConstant push_constant;
|
||||
push_constant.position[0] = position.x;
|
||||
push_constant.position[1] = position.y;
|
||||
push_constant.position[2] = position.z;
|
||||
push_constant.position[0] = fog_position.x;
|
||||
push_constant.position[1] = fog_position.y;
|
||||
push_constant.position[2] = fog_position.z;
|
||||
push_constant.size[0] = extents.x * 2;
|
||||
push_constant.size[1] = extents.y * 2;
|
||||
push_constant.size[2] = extents.z * 2;
|
||||
push_constant.corner[0] = min.x;
|
||||
push_constant.corner[1] = min.y;
|
||||
push_constant.corner[2] = min.z;
|
||||
push_constant.corner[0] = froxel_min.x;
|
||||
push_constant.corner[1] = froxel_min.y;
|
||||
push_constant.corner[2] = froxel_min.z;
|
||||
push_constant.shape = uint32_t(RendererRD::Fog::get_singleton()->fog_volume_get_shape(fog_volume));
|
||||
RendererRD::MaterialStorage::store_transform(fog_volume_instance->transform.affine_inverse(), push_constant.transform);
|
||||
|
||||
|
|
|
|||
|
|
@ -233,7 +233,7 @@ public:
|
|||
|
||||
/* FOG VOLUMES */
|
||||
|
||||
bool owns_fog_volume(RID p_rid) { return fog_volume_owner.owns(p_rid); };
|
||||
bool owns_fog_volume(RID p_rid) { return fog_volume_owner.owns(p_rid); }
|
||||
|
||||
virtual RID fog_volume_allocate() override;
|
||||
virtual void fog_volume_initialize(RID p_rid) override;
|
||||
|
|
@ -250,7 +250,7 @@ public:
|
|||
|
||||
/* FOG VOLUMES INSTANCE */
|
||||
|
||||
bool owns_fog_volume_instance(RID p_rid) { return fog_volume_instance_owner.owns(p_rid); };
|
||||
bool owns_fog_volume_instance(RID p_rid) { return fog_volume_instance_owner.owns(p_rid); }
|
||||
|
||||
RID fog_volume_instance_create(RID p_fog_volume);
|
||||
void fog_instance_free(RID p_rid);
|
||||
|
|
@ -316,8 +316,8 @@ public:
|
|||
|
||||
int last_shadow_filter = -1;
|
||||
|
||||
virtual void configure(RenderSceneBuffersRD *p_render_buffers) override{};
|
||||
virtual void free_data() override{};
|
||||
virtual void configure(RenderSceneBuffersRD *p_render_buffers) override {}
|
||||
virtual void free_data() override {}
|
||||
|
||||
bool sync_gi_dependent_sets_validity(bool p_ensure_freed = false);
|
||||
|
||||
|
|
|
|||
|
|
@ -350,7 +350,7 @@ bool GI::voxel_gi_is_using_two_bounces(RID p_voxel_gi) const {
|
|||
|
||||
bool GI::voxel_gi_is_interior(RID p_voxel_gi) const {
|
||||
VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
|
||||
ERR_FAIL_NULL_V(voxel_gi, 0);
|
||||
ERR_FAIL_NULL_V(voxel_gi, false);
|
||||
return voxel_gi->interior;
|
||||
}
|
||||
|
||||
|
|
@ -1307,24 +1307,24 @@ void GI::SDFGI::update_probes(RID p_env, SkyRD::Sky *p_sky) {
|
|||
push_constant.store_ambient_texture = RendererSceneRenderRD::get_singleton()->environment_get_volumetric_fog_enabled(p_env);
|
||||
|
||||
RID sky_uniform_set = gi->sdfgi_shader.integrate_default_sky_uniform_set;
|
||||
push_constant.sky_mode = SDFGIShader::IntegratePushConstant::SKY_MODE_DISABLED;
|
||||
push_constant.sky_flags = 0;
|
||||
push_constant.y_mult = y_mult;
|
||||
|
||||
if (reads_sky && p_env.is_valid()) {
|
||||
push_constant.sky_energy = RendererSceneRenderRD::get_singleton()->environment_get_bg_energy_multiplier(p_env);
|
||||
|
||||
if (RendererSceneRenderRD::get_singleton()->environment_get_background(p_env) == RS::ENV_BG_CLEAR_COLOR) {
|
||||
push_constant.sky_mode = SDFGIShader::IntegratePushConstant::SKY_MODE_COLOR;
|
||||
push_constant.sky_flags |= SDFGIShader::IntegratePushConstant::SKY_FLAGS_MODE_COLOR;
|
||||
Color c = RSG::texture_storage->get_default_clear_color().srgb_to_linear();
|
||||
push_constant.sky_color[0] = c.r;
|
||||
push_constant.sky_color[1] = c.g;
|
||||
push_constant.sky_color[2] = c.b;
|
||||
push_constant.sky_color_or_orientation[0] = c.r;
|
||||
push_constant.sky_color_or_orientation[1] = c.g;
|
||||
push_constant.sky_color_or_orientation[2] = c.b;
|
||||
} else if (RendererSceneRenderRD::get_singleton()->environment_get_background(p_env) == RS::ENV_BG_COLOR) {
|
||||
push_constant.sky_mode = SDFGIShader::IntegratePushConstant::SKY_MODE_COLOR;
|
||||
push_constant.sky_flags |= SDFGIShader::IntegratePushConstant::SKY_FLAGS_MODE_COLOR;
|
||||
Color c = RendererSceneRenderRD::get_singleton()->environment_get_bg_color(p_env);
|
||||
push_constant.sky_color[0] = c.r;
|
||||
push_constant.sky_color[1] = c.g;
|
||||
push_constant.sky_color[2] = c.b;
|
||||
push_constant.sky_color_or_orientation[0] = c.r;
|
||||
push_constant.sky_color_or_orientation[1] = c.g;
|
||||
push_constant.sky_color_or_orientation[2] = c.b;
|
||||
|
||||
} else if (RendererSceneRenderRD::get_singleton()->environment_get_background(p_env) == RS::ENV_BG_SKY) {
|
||||
if (p_sky && p_sky->radiance.is_valid()) {
|
||||
|
|
@ -1350,7 +1350,16 @@ void GI::SDFGI::update_probes(RID p_env, SkyRD::Sky *p_sky) {
|
|||
integrate_sky_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, gi->sdfgi_shader.integrate.version_get_shader(gi->sdfgi_shader.integrate_shader, 0), 1);
|
||||
}
|
||||
sky_uniform_set = integrate_sky_uniform_set;
|
||||
push_constant.sky_mode = SDFGIShader::IntegratePushConstant::SKY_MODE_SKY;
|
||||
push_constant.sky_flags |= SDFGIShader::IntegratePushConstant::SKY_FLAGS_MODE_SKY;
|
||||
|
||||
// Encode sky orientation as quaternion in existing push constants.
|
||||
const Basis sky_basis = RendererSceneRenderRD::get_singleton()->environment_get_sky_orientation(p_env);
|
||||
const Quaternion sky_quaternion = sky_basis.get_quaternion().inverse();
|
||||
push_constant.sky_color_or_orientation[0] = sky_quaternion.x;
|
||||
push_constant.sky_color_or_orientation[1] = sky_quaternion.y;
|
||||
push_constant.sky_color_or_orientation[2] = sky_quaternion.z;
|
||||
// Ideally we would reconstruct the largest component for least error, but sky contribution to GI is low frequency so just needs to get the idea across.
|
||||
push_constant.sky_flags |= SDFGIShader::IntegratePushConstant::SKY_FLAGS_ORIENTATION_SIGN * (sky_quaternion.w < 0.0 ? 0 : 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1396,7 +1405,7 @@ void GI::SDFGI::store_probes() {
|
|||
push_constant.image_size[1] = probe_axis_count;
|
||||
push_constant.store_ambient_texture = false;
|
||||
|
||||
push_constant.sky_mode = 0;
|
||||
push_constant.sky_flags = 0;
|
||||
push_constant.y_mult = y_mult;
|
||||
|
||||
// Then store values into the lightprobe texture. Separating these steps has a small performance hit, but it allows for multiple bounces
|
||||
|
|
@ -1721,7 +1730,7 @@ void GI::SDFGI::debug_probes(RID p_framebuffer, const uint32_t p_view_count, con
|
|||
|
||||
SDFGIShader::ProbeDebugMode mode = p_view_count > 1 ? SDFGIShader::PROBE_DEBUG_PROBES_MULTIVIEW : SDFGIShader::PROBE_DEBUG_PROBES;
|
||||
|
||||
RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_framebuffer, RD::INITIAL_ACTION_LOAD, RD::FINAL_ACTION_STORE, RD::INITIAL_ACTION_LOAD, RD::FINAL_ACTION_STORE);
|
||||
RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_framebuffer);
|
||||
RD::get_singleton()->draw_command_begin_label("Debug SDFGI");
|
||||
|
||||
RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, gi->sdfgi_shader.debug_probes_pipeline[mode].get_render_pipeline(RD::INVALID_FORMAT_ID, RD::get_singleton()->framebuffer_get_format(p_framebuffer)));
|
||||
|
|
@ -2092,11 +2101,11 @@ void GI::SDFGI::render_region(Ref<RenderSceneBuffersRD> p_render_buffers, int p_
|
|||
ipush_constant.history_size = history_size;
|
||||
ipush_constant.ray_count = 0;
|
||||
ipush_constant.ray_bias = 0;
|
||||
ipush_constant.sky_mode = 0;
|
||||
ipush_constant.sky_flags = 0;
|
||||
ipush_constant.sky_energy = 0;
|
||||
ipush_constant.sky_color[0] = 0;
|
||||
ipush_constant.sky_color[1] = 0;
|
||||
ipush_constant.sky_color[2] = 0;
|
||||
ipush_constant.sky_color_or_orientation[0] = 0;
|
||||
ipush_constant.sky_color_or_orientation[1] = 0;
|
||||
ipush_constant.sky_color_or_orientation[2] = 0;
|
||||
ipush_constant.y_mult = y_mult;
|
||||
ipush_constant.store_ambient_texture = false;
|
||||
|
||||
|
|
@ -2150,8 +2159,8 @@ void GI::SDFGI::render_region(Ref<RenderSceneBuffersRD> p_render_buffers, int p_
|
|||
}
|
||||
|
||||
//clear dispatch indirect data
|
||||
uint32_t dispatch_indirct_data[4] = { 0, 0, 0, 0 };
|
||||
RD::get_singleton()->buffer_update(cascades[cascade].solid_cell_dispatch_buffer_storage, 0, sizeof(uint32_t) * 4, dispatch_indirct_data);
|
||||
uint32_t dispatch_indirect_data[4] = { 0, 0, 0, 0 };
|
||||
RD::get_singleton()->buffer_update(cascades[cascade].solid_cell_dispatch_buffer_storage, 0, sizeof(uint32_t) * 4, dispatch_indirect_data);
|
||||
|
||||
RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
|
||||
|
||||
|
|
|
|||
|
|
@ -392,9 +392,9 @@ private:
|
|||
};
|
||||
struct IntegratePushConstant {
|
||||
enum {
|
||||
SKY_MODE_DISABLED,
|
||||
SKY_MODE_COLOR,
|
||||
SKY_MODE_SKY,
|
||||
SKY_FLAGS_MODE_COLOR = 0x01,
|
||||
SKY_FLAGS_MODE_SKY = 0x02,
|
||||
SKY_FLAGS_ORIENTATION_SIGN = 0x04,
|
||||
};
|
||||
|
||||
float grid_size[3];
|
||||
|
|
@ -410,12 +410,12 @@ private:
|
|||
int32_t image_size[2];
|
||||
|
||||
int32_t world_offset[3];
|
||||
uint32_t sky_mode;
|
||||
uint32_t sky_flags;
|
||||
|
||||
int32_t scroll[3];
|
||||
float sky_energy;
|
||||
|
||||
float sky_color[3];
|
||||
float sky_color_or_orientation[3];
|
||||
float y_mult;
|
||||
|
||||
uint32_t store_ambient_texture;
|
||||
|
|
@ -461,13 +461,13 @@ public:
|
|||
|
||||
RID get_voxel_gi_buffer();
|
||||
|
||||
virtual void configure(RenderSceneBuffersRD *p_render_buffers) override{};
|
||||
virtual void configure(RenderSceneBuffersRD *p_render_buffers) override {}
|
||||
virtual void free_data() override;
|
||||
};
|
||||
|
||||
/* VOXEL GI API */
|
||||
|
||||
bool owns_voxel_gi(RID p_rid) { return voxel_gi_owner.owns(p_rid); };
|
||||
bool owns_voxel_gi(RID p_rid) { return voxel_gi_owner.owns(p_rid); }
|
||||
|
||||
virtual RID voxel_gi_allocate() override;
|
||||
virtual void voxel_gi_free(RID p_voxel_gi) override;
|
||||
|
|
@ -524,14 +524,14 @@ public:
|
|||
VoxelGIInstance *voxel_gi = voxel_gi_instance_owner.get_or_null(p_probe);
|
||||
ERR_FAIL_NULL_V(voxel_gi, RID());
|
||||
return voxel_gi->texture;
|
||||
};
|
||||
}
|
||||
|
||||
_FORCE_INLINE_ void voxel_gi_instance_set_render_index(RID p_probe, uint32_t p_index) {
|
||||
VoxelGIInstance *voxel_gi = voxel_gi_instance_owner.get_or_null(p_probe);
|
||||
ERR_FAIL_NULL(voxel_gi);
|
||||
|
||||
voxel_gi->render_index = p_index;
|
||||
};
|
||||
}
|
||||
|
||||
bool voxel_gi_instance_owns(RID p_rid) const {
|
||||
return voxel_gi_instance_owner.owns(p_rid);
|
||||
|
|
@ -675,7 +675,7 @@ public:
|
|||
int32_t cascade_dynamic_light_count[SDFGI::MAX_CASCADES]; //used dynamically
|
||||
RID integrate_sky_uniform_set;
|
||||
|
||||
virtual void configure(RenderSceneBuffersRD *p_render_buffers) override{};
|
||||
virtual void configure(RenderSceneBuffersRD *p_render_buffers) override {}
|
||||
virtual void free_data() override;
|
||||
~SDFGI();
|
||||
|
||||
|
|
|
|||
|
|
@ -210,7 +210,7 @@ static _FORCE_INLINE_ void store_transform_3x3(const Basis &p_basis, float *p_ar
|
|||
p_array[11] = 0;
|
||||
}
|
||||
|
||||
void SkyRD::_render_sky(RD::DrawListID p_list, float p_time, RID p_fb, PipelineCacheRD *p_pipeline, RID p_uniform_set, RID p_texture_set, const Projection &p_projection, const Basis &p_orientation, const Vector3 &p_position, float p_luminance_multiplier) {
|
||||
void SkyRD::_render_sky(RD::DrawListID p_list, float p_time, RID p_fb, PipelineCacheRD *p_pipeline, RID p_uniform_set, RID p_texture_set, const Projection &p_projection, const Basis &p_orientation, const Vector3 &p_position, float p_luminance_multiplier, float p_brightness_multiplier) {
|
||||
SkyPushConstant sky_push_constant;
|
||||
|
||||
memset(&sky_push_constant, 0, sizeof(SkyPushConstant));
|
||||
|
|
@ -226,6 +226,7 @@ void SkyRD::_render_sky(RD::DrawListID p_list, float p_time, RID p_fb, PipelineC
|
|||
sky_push_constant.position[2] = p_position.z;
|
||||
sky_push_constant.time = p_time;
|
||||
sky_push_constant.luminance_multiplier = p_luminance_multiplier;
|
||||
sky_push_constant.brightness_multiplier = p_brightness_multiplier;
|
||||
store_transform_3x3(p_orientation, sky_push_constant.orientation);
|
||||
|
||||
RenderingDevice::FramebufferFormatID fb_format = RD::get_singleton()->framebuffer_get_format(p_fb);
|
||||
|
|
@ -545,7 +546,6 @@ void SkyRD::Sky::free() {
|
|||
}
|
||||
|
||||
if (material.is_valid()) {
|
||||
RSG::material_storage->material_free(material);
|
||||
material = RID();
|
||||
}
|
||||
}
|
||||
|
|
@ -553,7 +553,9 @@ void SkyRD::Sky::free() {
|
|||
RID SkyRD::Sky::get_textures(SkyTextureSetVersion p_version, RID p_default_shader_rd, Ref<RenderSceneBuffersRD> p_render_buffers) {
|
||||
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
|
||||
|
||||
Vector<RD::Uniform> uniforms;
|
||||
thread_local LocalVector<RD::Uniform> uniforms;
|
||||
uniforms.clear();
|
||||
|
||||
{
|
||||
RD::Uniform u;
|
||||
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
||||
|
|
@ -702,7 +704,7 @@ RendererRD::MaterialStorage::ShaderData *SkyRD::_create_sky_shader_func() {
|
|||
RendererRD::MaterialStorage::ShaderData *SkyRD::_create_sky_shader_funcs() {
|
||||
// !BAS! Why isn't _create_sky_shader_func not just static too?
|
||||
return static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton)->sky._create_sky_shader_func();
|
||||
};
|
||||
}
|
||||
|
||||
RendererRD::MaterialStorage::MaterialData *SkyRD::_create_sky_material_func(SkyShaderData *p_shader) {
|
||||
SkyMaterialData *material_data = memnew(SkyMaterialData);
|
||||
|
|
@ -714,7 +716,7 @@ RendererRD::MaterialStorage::MaterialData *SkyRD::_create_sky_material_func(SkyS
|
|||
RendererRD::MaterialStorage::MaterialData *SkyRD::_create_sky_material_funcs(RendererRD::MaterialStorage::ShaderData *p_shader) {
|
||||
// !BAS! same here, we could just make _create_sky_material_func static?
|
||||
return static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton)->sky._create_sky_material_func(static_cast<SkyShaderData *>(p_shader));
|
||||
};
|
||||
}
|
||||
|
||||
SkyRD::SkyRD() {
|
||||
roughness_layers = GLOBAL_GET("rendering/reflections/sky_reflections/roughness_layers");
|
||||
|
|
@ -874,7 +876,7 @@ void sky() {
|
|||
uniforms.push_back(u);
|
||||
}
|
||||
|
||||
uniforms.append_array(material_storage->samplers_rd_get_default().get_uniforms(SAMPLERS_BINDING_FIRST_INDEX));
|
||||
material_storage->samplers_rd_get_default().append_uniforms(uniforms, SAMPLERS_BINDING_FIRST_INDEX);
|
||||
|
||||
sky_scene_state.uniform_set = RD::get_singleton()->uniform_set_create(uniforms, sky_shader.default_shader_rd, SKY_SET_UNIFORMS);
|
||||
}
|
||||
|
|
@ -973,26 +975,26 @@ SkyRD::~SkyRD() {
|
|||
}
|
||||
}
|
||||
|
||||
void SkyRD::setup_sky(RID p_env, Ref<RenderSceneBuffersRD> p_render_buffers, const PagedArray<RID> &p_lights, RID p_camera_attributes, uint32_t p_view_count, const Projection *p_view_projections, const Vector3 *p_view_eye_offsets, const Transform3D &p_cam_transform, const Projection &p_cam_projection, const Size2i p_screen_size, Vector2 p_jitter, RendererSceneRenderRD *p_scene_render) {
|
||||
void SkyRD::setup_sky(const RenderDataRD *p_render_data, const Size2i p_screen_size) {
|
||||
RendererRD::LightStorage *light_storage = RendererRD::LightStorage::get_singleton();
|
||||
RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
|
||||
ERR_FAIL_COND(p_env.is_null());
|
||||
ERR_FAIL_COND(p_render_data->environment.is_null());
|
||||
|
||||
ERR_FAIL_COND(p_render_buffers.is_null());
|
||||
ERR_FAIL_COND(p_render_data->render_buffers.is_null());
|
||||
|
||||
// make sure we support our view count
|
||||
ERR_FAIL_COND(p_view_count == 0);
|
||||
ERR_FAIL_COND(p_view_count > RendererSceneRender::MAX_RENDER_VIEWS);
|
||||
ERR_FAIL_COND(p_render_data->scene_data->view_count == 0);
|
||||
ERR_FAIL_COND(p_render_data->scene_data->view_count > RendererSceneRender::MAX_RENDER_VIEWS);
|
||||
|
||||
SkyMaterialData *material = nullptr;
|
||||
Sky *sky = get_sky(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env));
|
||||
Sky *sky = get_sky(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_render_data->environment));
|
||||
|
||||
RID sky_material;
|
||||
|
||||
SkyShaderData *shader_data = nullptr;
|
||||
|
||||
if (sky) {
|
||||
sky_material = sky_get_material(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env));
|
||||
sky_material = sky_get_material(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_render_data->environment));
|
||||
|
||||
if (sky_material.is_valid()) {
|
||||
material = static_cast<SkyMaterialData *>(material_storage->material_get_data(sky_material, RendererRD::MaterialStorage::SHADER_TYPE_SKY));
|
||||
|
|
@ -1026,8 +1028,8 @@ void SkyRD::setup_sky(RID p_env, Ref<RenderSceneBuffersRD> p_render_buffers, con
|
|||
update_dirty_skys();
|
||||
}
|
||||
|
||||
if (shader_data->uses_time && p_scene_render->time - sky->prev_time > 0.00001) {
|
||||
sky->prev_time = p_scene_render->time;
|
||||
if (shader_data->uses_time && p_render_data->scene_data->time - sky->prev_time > 0.00001) {
|
||||
sky->prev_time = p_render_data->scene_data->time;
|
||||
sky->reflection.dirty = true;
|
||||
RenderingServerDefault::redraw_request();
|
||||
}
|
||||
|
|
@ -1042,29 +1044,30 @@ void SkyRD::setup_sky(RID p_env, Ref<RenderSceneBuffersRD> p_render_buffers, con
|
|||
sky->reflection.dirty = true;
|
||||
}
|
||||
|
||||
if (!p_cam_transform.origin.is_equal_approx(sky->prev_position) && shader_data->uses_position) {
|
||||
sky->prev_position = p_cam_transform.origin;
|
||||
if (!p_render_data->scene_data->cam_transform.origin.is_equal_approx(sky->prev_position) && shader_data->uses_position) {
|
||||
sky->prev_position = p_render_data->scene_data->cam_transform.origin;
|
||||
sky->reflection.dirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
sky_scene_state.ubo.directional_light_count = 0;
|
||||
if (shader_data->uses_light) {
|
||||
const PagedArray<RID> &lights = *p_render_data->lights;
|
||||
// Run through the list of lights in the scene and pick out the Directional Lights.
|
||||
// This can't be done in RenderSceneRenderRD::_setup lights because that needs to be called
|
||||
// after the depth prepass, but this runs before the depth prepass.
|
||||
for (int i = 0; i < (int)p_lights.size(); i++) {
|
||||
if (!light_storage->owns_light_instance(p_lights[i])) {
|
||||
for (int i = 0; i < (int)lights.size(); i++) {
|
||||
if (!light_storage->owns_light_instance(lights[i])) {
|
||||
continue;
|
||||
}
|
||||
RID base = light_storage->light_instance_get_base_light(p_lights[i]);
|
||||
RID base = light_storage->light_instance_get_base_light(lights[i]);
|
||||
|
||||
ERR_CONTINUE(base.is_null());
|
||||
|
||||
RS::LightType type = light_storage->light_get_type(base);
|
||||
if (type == RS::LIGHT_DIRECTIONAL && light_storage->light_directional_get_sky_mode(base) != RS::LIGHT_DIRECTIONAL_SKY_MODE_LIGHT_ONLY) {
|
||||
SkyDirectionalLightData &sky_light_data = sky_scene_state.directional_lights[sky_scene_state.ubo.directional_light_count];
|
||||
Transform3D light_transform = light_storage->light_instance_get_base_transform(p_lights[i]);
|
||||
Transform3D light_transform = light_storage->light_instance_get_base_transform(lights[i]);
|
||||
Vector3 world_direction = light_transform.basis.xform(Vector3(0, 0, 1)).normalized();
|
||||
|
||||
sky_light_data.direction[0] = world_direction.x;
|
||||
|
|
@ -1074,12 +1077,12 @@ void SkyRD::setup_sky(RID p_env, Ref<RenderSceneBuffersRD> p_render_buffers, con
|
|||
float sign = light_storage->light_is_negative(base) ? -1 : 1;
|
||||
sky_light_data.energy = sign * light_storage->light_get_param(base, RS::LIGHT_PARAM_ENERGY);
|
||||
|
||||
if (p_scene_render->is_using_physical_light_units()) {
|
||||
if (RendererSceneRenderRD::get_singleton()->is_using_physical_light_units()) {
|
||||
sky_light_data.energy *= light_storage->light_get_param(base, RS::LIGHT_PARAM_INTENSITY);
|
||||
}
|
||||
|
||||
if (p_camera_attributes.is_valid()) {
|
||||
sky_light_data.energy *= RSG::camera_attributes->camera_attributes_get_exposure_normalization_factor(p_camera_attributes);
|
||||
if (p_render_data->camera_attributes.is_valid()) {
|
||||
sky_light_data.energy *= RSG::camera_attributes->camera_attributes_get_exposure_normalization_factor(p_render_data->camera_attributes);
|
||||
}
|
||||
|
||||
Color linear_col = light_storage->light_get_color(base).srgb_to_linear();
|
||||
|
|
@ -1150,43 +1153,59 @@ void SkyRD::setup_sky(RID p_env, Ref<RenderSceneBuffersRD> p_render_buffers, con
|
|||
|
||||
// Setup fog variables.
|
||||
sky_scene_state.ubo.volumetric_fog_enabled = false;
|
||||
if (p_render_buffers.is_valid()) {
|
||||
if (p_render_buffers->has_custom_data(RB_SCOPE_FOG)) {
|
||||
Ref<RendererRD::Fog::VolumetricFog> fog = p_render_buffers->get_custom_data(RB_SCOPE_FOG);
|
||||
sky_scene_state.ubo.volumetric_fog_enabled = true;
|
||||
if (p_render_data->render_buffers->has_custom_data(RB_SCOPE_FOG)) {
|
||||
Ref<RendererRD::Fog::VolumetricFog> fog = p_render_data->render_buffers->get_custom_data(RB_SCOPE_FOG);
|
||||
sky_scene_state.ubo.volumetric_fog_enabled = true;
|
||||
|
||||
float fog_end = fog->length;
|
||||
if (fog_end > 0.0) {
|
||||
sky_scene_state.ubo.volumetric_fog_inv_length = 1.0 / fog_end;
|
||||
} else {
|
||||
sky_scene_state.ubo.volumetric_fog_inv_length = 1.0;
|
||||
}
|
||||
|
||||
float fog_detail_spread = fog->spread; // Reverse lookup.
|
||||
if (fog_detail_spread > 0.0) {
|
||||
sky_scene_state.ubo.volumetric_fog_detail_spread = 1.0 / fog_detail_spread;
|
||||
} else {
|
||||
sky_scene_state.ubo.volumetric_fog_detail_spread = 1.0;
|
||||
}
|
||||
|
||||
sky_scene_state.fog_uniform_set = fog->sky_uniform_set;
|
||||
float fog_end = fog->length;
|
||||
if (fog_end > 0.0) {
|
||||
sky_scene_state.ubo.volumetric_fog_inv_length = 1.0 / fog_end;
|
||||
} else {
|
||||
sky_scene_state.ubo.volumetric_fog_inv_length = 1.0;
|
||||
}
|
||||
|
||||
float fog_detail_spread = fog->spread; // Reverse lookup.
|
||||
if (fog_detail_spread > 0.0) {
|
||||
sky_scene_state.ubo.volumetric_fog_detail_spread = 1.0 / fog_detail_spread;
|
||||
} else {
|
||||
sky_scene_state.ubo.volumetric_fog_detail_spread = 1.0;
|
||||
}
|
||||
|
||||
sky_scene_state.fog_uniform_set = fog->sky_uniform_set;
|
||||
}
|
||||
|
||||
Projection correction;
|
||||
correction.set_depth_correction(false, true);
|
||||
correction.add_jitter_offset(p_jitter);
|
||||
sky_scene_state.view_count = p_render_data->scene_data->view_count;
|
||||
sky_scene_state.cam_transform = p_render_data->scene_data->cam_transform;
|
||||
|
||||
sky_scene_state.view_count = p_view_count;
|
||||
sky_scene_state.cam_transform = p_cam_transform;
|
||||
sky_scene_state.cam_projection = correction * p_cam_projection; // We only use this when rendering a single view.
|
||||
Projection correction;
|
||||
correction.set_depth_correction(p_render_data->scene_data->flip_y, true);
|
||||
correction.add_jitter_offset(p_render_data->scene_data->taa_jitter);
|
||||
|
||||
Projection projection = p_render_data->scene_data->cam_projection;
|
||||
if (p_render_data->scene_data->cam_frustum) {
|
||||
// We don't use a full projection matrix for the sky, this is enough to make up for it.
|
||||
projection[2].y = -projection[2].y;
|
||||
}
|
||||
|
||||
float custom_fov = RendererSceneRenderRD::get_singleton()->environment_get_sky_custom_fov(p_render_data->environment);
|
||||
|
||||
if (custom_fov && sky_scene_state.view_count == 1) {
|
||||
// With custom fov we don't support stereo...
|
||||
float near_plane = projection.get_z_near();
|
||||
float far_plane = projection.get_z_far();
|
||||
float aspect = projection.get_aspect();
|
||||
|
||||
projection.set_perspective(custom_fov, aspect, near_plane, far_plane);
|
||||
}
|
||||
|
||||
sky_scene_state.cam_projection = correction * projection;
|
||||
|
||||
// Our info in our UBO is only used if we're rendering stereo.
|
||||
for (uint32_t i = 0; i < p_view_count; i++) {
|
||||
Projection view_inv_projection = (correction * p_view_projections[i]).inverse();
|
||||
if (p_view_count > 1) {
|
||||
for (uint32_t i = 0; i < p_render_data->scene_data->view_count; i++) {
|
||||
Projection view_inv_projection = (correction * p_render_data->scene_data->view_projection[i]).inverse();
|
||||
if (p_render_data->scene_data->view_count > 1) {
|
||||
// Reprojection is used when we need to have things in combined space.
|
||||
RendererRD::MaterialStorage::store_camera(p_cam_projection * view_inv_projection, sky_scene_state.ubo.combined_reprojection[i]);
|
||||
RendererRD::MaterialStorage::store_camera(p_render_data->scene_data->cam_projection * view_inv_projection, sky_scene_state.ubo.combined_reprojection[i]);
|
||||
} else {
|
||||
// This is unused so just reset to identity.
|
||||
Projection ident;
|
||||
|
|
@ -1194,30 +1213,30 @@ void SkyRD::setup_sky(RID p_env, Ref<RenderSceneBuffersRD> p_render_buffers, con
|
|||
}
|
||||
|
||||
RendererRD::MaterialStorage::store_camera(view_inv_projection, sky_scene_state.ubo.view_inv_projections[i]);
|
||||
sky_scene_state.ubo.view_eye_offsets[i][0] = p_view_eye_offsets[i].x;
|
||||
sky_scene_state.ubo.view_eye_offsets[i][1] = p_view_eye_offsets[i].y;
|
||||
sky_scene_state.ubo.view_eye_offsets[i][2] = p_view_eye_offsets[i].z;
|
||||
sky_scene_state.ubo.view_eye_offsets[i][0] = p_render_data->scene_data->view_eye_offset[i].x;
|
||||
sky_scene_state.ubo.view_eye_offsets[i][1] = p_render_data->scene_data->view_eye_offset[i].y;
|
||||
sky_scene_state.ubo.view_eye_offsets[i][2] = p_render_data->scene_data->view_eye_offset[i].z;
|
||||
sky_scene_state.ubo.view_eye_offsets[i][3] = 0.0;
|
||||
}
|
||||
|
||||
sky_scene_state.ubo.z_far = p_view_projections[0].get_z_far(); // Should be the same for all projection.
|
||||
sky_scene_state.ubo.fog_enabled = RendererSceneRenderRD::get_singleton()->environment_get_fog_enabled(p_env);
|
||||
sky_scene_state.ubo.fog_density = RendererSceneRenderRD::get_singleton()->environment_get_fog_density(p_env);
|
||||
sky_scene_state.ubo.fog_aerial_perspective = RendererSceneRenderRD::get_singleton()->environment_get_fog_aerial_perspective(p_env);
|
||||
Color fog_color = RendererSceneRenderRD::get_singleton()->environment_get_fog_light_color(p_env).srgb_to_linear();
|
||||
float fog_energy = RendererSceneRenderRD::get_singleton()->environment_get_fog_light_energy(p_env);
|
||||
sky_scene_state.ubo.z_far = p_render_data->scene_data->view_projection[0].get_z_far(); // Should be the same for all projection.
|
||||
sky_scene_state.ubo.fog_enabled = RendererSceneRenderRD::get_singleton()->environment_get_fog_enabled(p_render_data->environment);
|
||||
sky_scene_state.ubo.fog_density = RendererSceneRenderRD::get_singleton()->environment_get_fog_density(p_render_data->environment);
|
||||
sky_scene_state.ubo.fog_aerial_perspective = RendererSceneRenderRD::get_singleton()->environment_get_fog_aerial_perspective(p_render_data->environment);
|
||||
Color fog_color = RendererSceneRenderRD::get_singleton()->environment_get_fog_light_color(p_render_data->environment).srgb_to_linear();
|
||||
float fog_energy = RendererSceneRenderRD::get_singleton()->environment_get_fog_light_energy(p_render_data->environment);
|
||||
sky_scene_state.ubo.fog_light_color[0] = fog_color.r * fog_energy;
|
||||
sky_scene_state.ubo.fog_light_color[1] = fog_color.g * fog_energy;
|
||||
sky_scene_state.ubo.fog_light_color[2] = fog_color.b * fog_energy;
|
||||
sky_scene_state.ubo.fog_sun_scatter = RendererSceneRenderRD::get_singleton()->environment_get_fog_sun_scatter(p_env);
|
||||
sky_scene_state.ubo.fog_sun_scatter = RendererSceneRenderRD::get_singleton()->environment_get_fog_sun_scatter(p_render_data->environment);
|
||||
|
||||
sky_scene_state.ubo.fog_sky_affect = RendererSceneRenderRD::get_singleton()->environment_get_fog_sky_affect(p_env);
|
||||
sky_scene_state.ubo.volumetric_fog_sky_affect = RendererSceneRenderRD::get_singleton()->environment_get_volumetric_fog_sky_affect(p_env);
|
||||
sky_scene_state.ubo.fog_sky_affect = RendererSceneRenderRD::get_singleton()->environment_get_fog_sky_affect(p_render_data->environment);
|
||||
sky_scene_state.ubo.volumetric_fog_sky_affect = RendererSceneRenderRD::get_singleton()->environment_get_volumetric_fog_sky_affect(p_render_data->environment);
|
||||
|
||||
RD::get_singleton()->buffer_update(sky_scene_state.uniform_buffer, 0, sizeof(SkySceneState::UBO), &sky_scene_state.ubo);
|
||||
}
|
||||
|
||||
void SkyRD::update_radiance_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, const Vector3 &p_global_pos, double p_time, float p_luminance_multiplier) {
|
||||
void SkyRD::update_radiance_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, const Vector3 &p_global_pos, double p_time, float p_luminance_multiplier, float p_brightness_multiplier) {
|
||||
ERR_FAIL_COND(p_render_buffers.is_null());
|
||||
RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
|
||||
ERR_FAIL_COND(p_env.is_null());
|
||||
|
|
@ -1251,7 +1270,7 @@ void SkyRD::update_radiance_buffers(Ref<RenderSceneBuffersRD> p_render_buffers,
|
|||
RS::SkyMode sky_mode = sky->mode;
|
||||
|
||||
if (sky_mode == RS::SKY_MODE_AUTOMATIC) {
|
||||
if (shader_data->uses_time || shader_data->uses_position) {
|
||||
if ((shader_data->uses_time || shader_data->uses_position) && sky->radiance_size == 256) {
|
||||
update_single_frame = true;
|
||||
sky_mode = RS::SKY_MODE_REALTIME;
|
||||
} else if (shader_data->uses_light || shader_data->ubo_size > 0) {
|
||||
|
|
@ -1293,7 +1312,7 @@ void SkyRD::update_radiance_buffers(Ref<RenderSceneBuffersRD> p_render_buffers,
|
|||
Projection cm;
|
||||
cm.set_perspective(90, 1, 0.01, 10.0);
|
||||
Projection correction;
|
||||
correction.set_depth_correction(true);
|
||||
correction.set_depth_correction(false);
|
||||
cm = correction * cm;
|
||||
|
||||
// Note, we ignore environment_get_sky_orientation here as this is applied when we do our lookup in our scene shader.
|
||||
|
|
@ -1310,8 +1329,8 @@ void SkyRD::update_radiance_buffers(Ref<RenderSceneBuffersRD> p_render_buffers,
|
|||
Basis local_view = Basis::looking_at(view_normals[i], view_up[i]);
|
||||
RID texture_uniform_set = sky->get_textures(SKY_TEXTURE_SET_CUBEMAP_QUARTER_RES, sky_shader.default_shader_rd, p_render_buffers);
|
||||
|
||||
cubemap_draw_list = RD::get_singleton()->draw_list_begin(sky->reflection.layers[0].mipmaps[2].framebuffers[i], RD::INITIAL_ACTION_LOAD, RD::FINAL_ACTION_STORE, RD::INITIAL_ACTION_LOAD, RD::FINAL_ACTION_DISCARD);
|
||||
_render_sky(cubemap_draw_list, p_time, sky->reflection.layers[0].mipmaps[2].framebuffers[i], pipeline, material->uniform_set, texture_uniform_set, cm, local_view, p_global_pos, p_luminance_multiplier);
|
||||
cubemap_draw_list = RD::get_singleton()->draw_list_begin(sky->reflection.layers[0].mipmaps[2].framebuffers[i]);
|
||||
_render_sky(cubemap_draw_list, p_time, sky->reflection.layers[0].mipmaps[2].framebuffers[i], pipeline, material->uniform_set, texture_uniform_set, cm, local_view, p_global_pos, p_luminance_multiplier, p_brightness_multiplier);
|
||||
RD::get_singleton()->draw_list_end();
|
||||
}
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
|
|
@ -1331,8 +1350,8 @@ void SkyRD::update_radiance_buffers(Ref<RenderSceneBuffersRD> p_render_buffers,
|
|||
Basis local_view = Basis::looking_at(view_normals[i], view_up[i]);
|
||||
RID texture_uniform_set = sky->get_textures(SKY_TEXTURE_SET_CUBEMAP_HALF_RES, sky_shader.default_shader_rd, p_render_buffers);
|
||||
|
||||
cubemap_draw_list = RD::get_singleton()->draw_list_begin(sky->reflection.layers[0].mipmaps[1].framebuffers[i], RD::INITIAL_ACTION_LOAD, RD::FINAL_ACTION_STORE, RD::INITIAL_ACTION_LOAD, RD::FINAL_ACTION_DISCARD);
|
||||
_render_sky(cubemap_draw_list, p_time, sky->reflection.layers[0].mipmaps[1].framebuffers[i], pipeline, material->uniform_set, texture_uniform_set, cm, local_view, p_global_pos, p_luminance_multiplier);
|
||||
cubemap_draw_list = RD::get_singleton()->draw_list_begin(sky->reflection.layers[0].mipmaps[1].framebuffers[i]);
|
||||
_render_sky(cubemap_draw_list, p_time, sky->reflection.layers[0].mipmaps[1].framebuffers[i], pipeline, material->uniform_set, texture_uniform_set, cm, local_view, p_global_pos, p_luminance_multiplier, p_brightness_multiplier);
|
||||
RD::get_singleton()->draw_list_end();
|
||||
}
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
|
|
@ -1348,8 +1367,8 @@ void SkyRD::update_radiance_buffers(Ref<RenderSceneBuffersRD> p_render_buffers,
|
|||
Basis local_view = Basis::looking_at(view_normals[i], view_up[i]);
|
||||
RID texture_uniform_set = sky->get_textures(SKY_TEXTURE_SET_CUBEMAP, sky_shader.default_shader_rd, p_render_buffers);
|
||||
|
||||
cubemap_draw_list = RD::get_singleton()->draw_list_begin(sky->reflection.layers[0].mipmaps[0].framebuffers[i], RD::INITIAL_ACTION_LOAD, RD::FINAL_ACTION_STORE, RD::INITIAL_ACTION_LOAD, RD::FINAL_ACTION_DISCARD);
|
||||
_render_sky(cubemap_draw_list, p_time, sky->reflection.layers[0].mipmaps[0].framebuffers[i], pipeline, material->uniform_set, texture_uniform_set, cm, local_view, p_global_pos, p_luminance_multiplier);
|
||||
cubemap_draw_list = RD::get_singleton()->draw_list_begin(sky->reflection.layers[0].mipmaps[0].framebuffers[i], RD::DRAW_DEFAULT_ALL, Vector<Color>(), 1.0f, 0, Rect2(), RDD::BreadcrumbMarker::SKY_PASS | uint32_t(i));
|
||||
_render_sky(cubemap_draw_list, p_time, sky->reflection.layers[0].mipmaps[0].framebuffers[i], pipeline, material->uniform_set, texture_uniform_set, cm, local_view, p_global_pos, p_luminance_multiplier, p_brightness_multiplier);
|
||||
RD::get_singleton()->draw_list_end();
|
||||
}
|
||||
RD::get_singleton()->draw_command_end_label();
|
||||
|
|
@ -1391,7 +1410,7 @@ void SkyRD::update_radiance_buffers(Ref<RenderSceneBuffersRD> p_render_buffers,
|
|||
}
|
||||
}
|
||||
|
||||
void SkyRD::update_res_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, double p_time, float p_luminance_multiplier) {
|
||||
void SkyRD::update_res_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, double p_time, float p_luminance_multiplier, float p_brightness_multiplier) {
|
||||
ERR_FAIL_COND(p_render_buffers.is_null());
|
||||
RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
|
||||
ERR_FAIL_COND(p_env.is_null());
|
||||
|
|
@ -1442,20 +1461,9 @@ void SkyRD::update_res_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p
|
|||
Basis sky_transform = RendererSceneRenderRD::get_singleton()->environment_get_sky_orientation(p_env);
|
||||
sky_transform.invert();
|
||||
|
||||
float custom_fov = RendererSceneRenderRD::get_singleton()->environment_get_sky_custom_fov(p_env);
|
||||
|
||||
// Camera
|
||||
Projection projection = sky_scene_state.cam_projection;
|
||||
|
||||
if (custom_fov && sky_scene_state.view_count == 1) {
|
||||
// With custom fov we don't support stereo...
|
||||
float near_plane = projection.get_z_near();
|
||||
float far_plane = projection.get_z_far();
|
||||
float aspect = projection.get_aspect();
|
||||
|
||||
projection.set_perspective(custom_fov, aspect, near_plane, far_plane);
|
||||
}
|
||||
|
||||
sky_transform = sky_transform * sky_scene_state.cam_transform.basis;
|
||||
|
||||
if (shader_data->uses_quarter_res) {
|
||||
|
|
@ -1472,8 +1480,8 @@ void SkyRD::update_res_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p
|
|||
Vector<Color> clear_colors;
|
||||
clear_colors.push_back(Color(0.0, 0.0, 0.0));
|
||||
|
||||
RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_STORE, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_DISCARD, clear_colors, 0.0);
|
||||
_render_sky(draw_list, p_time, framebuffer, pipeline, material->uniform_set, texture_uniform_set, projection, sky_transform, sky_scene_state.cam_transform.origin, p_luminance_multiplier);
|
||||
RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(framebuffer, RD::DRAW_CLEAR_ALL, clear_colors);
|
||||
_render_sky(draw_list, p_time, framebuffer, pipeline, material->uniform_set, texture_uniform_set, projection, sky_transform, sky_scene_state.cam_transform.origin, p_luminance_multiplier, p_brightness_multiplier);
|
||||
RD::get_singleton()->draw_list_end();
|
||||
}
|
||||
|
||||
|
|
@ -1491,15 +1499,15 @@ void SkyRD::update_res_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p
|
|||
Vector<Color> clear_colors;
|
||||
clear_colors.push_back(Color(0.0, 0.0, 0.0));
|
||||
|
||||
RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_STORE, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_DISCARD, clear_colors, 0.0);
|
||||
_render_sky(draw_list, p_time, framebuffer, pipeline, material->uniform_set, texture_uniform_set, projection, sky_transform, sky_scene_state.cam_transform.origin, p_luminance_multiplier);
|
||||
RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(framebuffer, RD::DRAW_CLEAR_ALL, clear_colors);
|
||||
_render_sky(draw_list, p_time, framebuffer, pipeline, material->uniform_set, texture_uniform_set, projection, sky_transform, sky_scene_state.cam_transform.origin, p_luminance_multiplier, p_brightness_multiplier);
|
||||
RD::get_singleton()->draw_list_end();
|
||||
}
|
||||
|
||||
RD::get_singleton()->draw_command_end_label(); // Setup Sky resolution buffers
|
||||
}
|
||||
|
||||
void SkyRD::draw_sky(RD::DrawListID p_draw_list, Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, RID p_fb, double p_time, float p_luminance_multiplier) {
|
||||
void SkyRD::draw_sky(RD::DrawListID p_draw_list, Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, RID p_fb, double p_time, float p_luminance_multiplier, float p_brightness_multiplier) {
|
||||
ERR_FAIL_COND(p_render_buffers.is_null());
|
||||
RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
|
||||
ERR_FAIL_COND(p_env.is_null());
|
||||
|
|
@ -1543,20 +1551,9 @@ void SkyRD::draw_sky(RD::DrawListID p_draw_list, Ref<RenderSceneBuffersRD> p_ren
|
|||
Basis sky_transform = RendererSceneRenderRD::get_singleton()->environment_get_sky_orientation(p_env);
|
||||
sky_transform.invert();
|
||||
|
||||
float custom_fov = RendererSceneRenderRD::get_singleton()->environment_get_sky_custom_fov(p_env);
|
||||
|
||||
// Camera
|
||||
Projection projection = sky_scene_state.cam_projection;
|
||||
|
||||
if (custom_fov && sky_scene_state.view_count == 1) {
|
||||
// With custom fov we don't support stereo...
|
||||
float near_plane = projection.get_z_near();
|
||||
float far_plane = projection.get_z_far();
|
||||
float aspect = projection.get_aspect();
|
||||
|
||||
projection.set_perspective(custom_fov, aspect, near_plane, far_plane);
|
||||
}
|
||||
|
||||
sky_transform = sky_transform * sky_scene_state.cam_transform.basis;
|
||||
|
||||
PipelineCacheRD *pipeline = &shader_data->pipelines[sky_scene_state.view_count > 1 ? SKY_VERSION_BACKGROUND_MULTIVIEW : SKY_VERSION_BACKGROUND];
|
||||
|
|
@ -1568,7 +1565,7 @@ void SkyRD::draw_sky(RD::DrawListID p_draw_list, Ref<RenderSceneBuffersRD> p_ren
|
|||
texture_uniform_set = sky_scene_state.fog_only_texture_uniform_set;
|
||||
}
|
||||
|
||||
_render_sky(p_draw_list, p_time, p_fb, pipeline, material->uniform_set, texture_uniform_set, projection, sky_transform, sky_scene_state.cam_transform.origin, p_luminance_multiplier);
|
||||
_render_sky(p_draw_list, p_time, p_fb, pipeline, material->uniform_set, texture_uniform_set, projection, sky_transform, sky_scene_state.cam_transform.origin, p_luminance_multiplier, p_brightness_multiplier);
|
||||
}
|
||||
|
||||
void SkyRD::invalidate_sky(Sky *p_sky) {
|
||||
|
|
|
|||
|
|
@ -36,6 +36,7 @@
|
|||
#include "servers/rendering/renderer_rd/pipeline_cache_rd.h"
|
||||
#include "servers/rendering/renderer_rd/shaders/environment/sky.glsl.gen.h"
|
||||
#include "servers/rendering/renderer_rd/storage_rd/material_storage.h"
|
||||
#include "servers/rendering/renderer_rd/storage_rd/render_data_rd.h"
|
||||
#include "servers/rendering/renderer_scene_render.h"
|
||||
#include "servers/rendering/rendering_device.h"
|
||||
#include "servers/rendering/shader_compiler.h"
|
||||
|
|
@ -100,8 +101,9 @@ private:
|
|||
float projection[4]; // 16 - 64
|
||||
float position[3]; // 12 - 76
|
||||
float time; // 4 - 80
|
||||
float pad[3]; // 12 - 92
|
||||
float luminance_multiplier; // 4 - 96
|
||||
float pad[2]; // 8 - 88
|
||||
float luminance_multiplier; // 4 - 92
|
||||
float brightness_multiplier; // 4 - 96
|
||||
// 128 is the max size of a push constant. We can replace "pad" but we can't add any more.
|
||||
};
|
||||
|
||||
|
|
@ -132,7 +134,7 @@ private:
|
|||
virtual ~SkyShaderData();
|
||||
};
|
||||
|
||||
void _render_sky(RD::DrawListID p_list, float p_time, RID p_fb, PipelineCacheRD *p_pipeline, RID p_uniform_set, RID p_texture_set, const Projection &p_projection, const Basis &p_orientation, const Vector3 &p_position, float p_luminance_multiplier);
|
||||
void _render_sky(RD::DrawListID p_list, float p_time, RID p_fb, PipelineCacheRD *p_pipeline, RID p_uniform_set, RID p_texture_set, const Projection &p_projection, const Basis &p_orientation, const Vector3 &p_position, float p_luminance_multiplier, float p_brightness_modifier);
|
||||
|
||||
public:
|
||||
struct SkySceneState {
|
||||
|
|
@ -294,10 +296,10 @@ public:
|
|||
void set_texture_format(RD::DataFormat p_texture_format);
|
||||
~SkyRD();
|
||||
|
||||
void setup_sky(RID p_env, Ref<RenderSceneBuffersRD> p_render_buffers, const PagedArray<RID> &p_lights, RID p_camera_attributes, uint32_t p_view_count, const Projection *p_view_projections, const Vector3 *p_view_eye_offsets, const Transform3D &p_cam_transform, const Projection &p_cam_projection, const Size2i p_screen_size, Vector2 p_jitter, RendererSceneRenderRD *p_scene_render);
|
||||
void update_radiance_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, const Vector3 &p_global_pos, double p_time, float p_luminance_multiplier = 1.0);
|
||||
void update_res_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, double p_time, float p_luminance_multiplier = 1.0);
|
||||
void draw_sky(RD::DrawListID p_draw_list, Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, RID p_fb, double p_time, float p_luminance_multiplier = 1.0);
|
||||
void setup_sky(const RenderDataRD *p_render_data, const Size2i p_screen_size);
|
||||
void update_radiance_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, const Vector3 &p_global_pos, double p_time, float p_luminance_multiplier = 1.0, float p_brightness_multiplier = 1.0);
|
||||
void update_res_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, double p_time, float p_luminance_multiplier = 1.0, float p_brightness_multiplier = 1.0);
|
||||
void draw_sky(RD::DrawListID p_draw_list, Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, RID p_fb, double p_time, float p_luminance_multiplier = 1.0, float p_brightness_multiplier = 1.0);
|
||||
|
||||
void invalidate_sky(Sky *p_sky);
|
||||
void update_dirty_skys();
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue