Support light size and soft shadows
This commit is contained in:
Juan Linietsky
parent
26ecd924cc
commit
6a730ffeab
|
|
@ -216,6 +216,14 @@ bool Light3D::is_editor_only() const {
|
|||
}
|
||||
|
||||
void Light3D::_validate_property(PropertyInfo &property) const {
|
||||
|
||||
if (get_light_type() == RS::LIGHT_DIRECTIONAL && property.name == "light_size") {
|
||||
property.usage = 0;
|
||||
}
|
||||
|
||||
if (get_light_type() != RS::LIGHT_DIRECTIONAL && property.name == "light_angular_distance") {
|
||||
property.usage = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void Light3D::_bind_methods() {
|
||||
|
|
@ -251,6 +259,8 @@ void Light3D::_bind_methods() {
|
|||
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "light_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_color", "get_color");
|
||||
ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "light_energy", PROPERTY_HINT_RANGE, "0,16,0.01,or_greater"), "set_param", "get_param", PARAM_ENERGY);
|
||||
ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "light_indirect_energy", PROPERTY_HINT_RANGE, "0,16,0.01,or_greater"), "set_param", "get_param", PARAM_INDIRECT_ENERGY);
|
||||
ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "light_size", PROPERTY_HINT_RANGE, "0,64,0.01,or_greater"), "set_param", "get_param", PARAM_SIZE);
|
||||
ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "light_angular_distance", PROPERTY_HINT_RANGE, "0,90,0.01"), "set_param", "get_param", PARAM_SIZE);
|
||||
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "light_negative"), "set_negative", "is_negative");
|
||||
ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "light_specular", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param", "get_param", PARAM_SPECULAR);
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "light_bake_mode", PROPERTY_HINT_ENUM, "Disable,Indirect,All"), "set_bake_mode", "get_bake_mode");
|
||||
|
|
@ -315,6 +325,7 @@ Light3D::Light3D(RenderingServer::LightType p_type) {
|
|||
set_param(PARAM_INDIRECT_ENERGY, 1);
|
||||
set_param(PARAM_SPECULAR, 0.5);
|
||||
set_param(PARAM_RANGE, 5);
|
||||
set_param(PARAM_SIZE, 0);
|
||||
set_param(PARAM_ATTENUATION, 1);
|
||||
set_param(PARAM_SPOT_ANGLE, 45);
|
||||
set_param(PARAM_SPOT_ATTENUATION, 1);
|
||||
|
|
|
|||
|
|
@ -46,6 +46,7 @@ public:
|
|||
PARAM_INDIRECT_ENERGY = RS::LIGHT_PARAM_INDIRECT_ENERGY,
|
||||
PARAM_SPECULAR = RS::LIGHT_PARAM_SPECULAR,
|
||||
PARAM_RANGE = RS::LIGHT_PARAM_RANGE,
|
||||
PARAM_SIZE = RS::LIGHT_PARAM_SIZE,
|
||||
PARAM_ATTENUATION = RS::LIGHT_PARAM_ATTENUATION,
|
||||
PARAM_SPOT_ANGLE = RS::LIGHT_PARAM_SPOT_ANGLE,
|
||||
PARAM_SPOT_ATTENUATION = RS::LIGHT_PARAM_SPOT_ATTENUATION,
|
||||
|
|
|
|||
|
|
@ -231,7 +231,7 @@ public:
|
|||
|
||||
virtual RID light_instance_create(RID p_light) = 0;
|
||||
virtual void light_instance_set_transform(RID p_light_instance, const Transform &p_transform) = 0;
|
||||
virtual void light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale = 1.0) = 0;
|
||||
virtual void light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale = 1.0, float p_range_begin = 0, const Vector2 &p_uv_scale = Vector2()) = 0;
|
||||
virtual void light_instance_mark_visible(RID p_light_instance) = 0;
|
||||
virtual bool light_instances_can_render_shadow_cube() const {
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -965,6 +965,7 @@ void RasterizerSceneHighEndRD::_setup_environment(RID p_environment, const Camer
|
|||
scene_state.ubo.shadow_filter_mode = shadow_filter_get();
|
||||
|
||||
scene_state.ubo.pancake_shadows = p_pancake_shadows;
|
||||
scene_state.ubo.shadow_blocker_count = 16;
|
||||
|
||||
scene_state.ubo.screen_pixel_size[0] = p_screen_pixel_size.x;
|
||||
scene_state.ubo.screen_pixel_size[1] = p_screen_pixel_size.y;
|
||||
|
|
@ -1484,6 +1485,10 @@ void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_lig
|
|||
light_data.specular = storage->light_get_param(base, RS::LIGHT_PARAM_SPECULAR);
|
||||
light_data.mask = storage->light_get_cull_mask(base);
|
||||
|
||||
float size = storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
|
||||
|
||||
light_data.size = 1.0 - Math::cos(Math::deg2rad(size)); //angle to cosine offset
|
||||
|
||||
Color shadow_col = storage->light_get_shadow_color(base).to_linear();
|
||||
|
||||
if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_PSSM_SPLITS) {
|
||||
|
|
@ -1551,12 +1556,44 @@ void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_lig
|
|||
light_data.shadow_normal_bias[j] = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS) * light_instance_get_directional_shadow_texel_size(li, j);
|
||||
light_data.shadow_transmittance_bias[j] = storage->light_get_transmittance_bias(base) * bias_scale;
|
||||
light_data.shadow_transmittance_z_scale[j] = light_instance_get_shadow_range(li, j);
|
||||
light_data.shadow_range_begin[j] = light_instance_get_shadow_range_begin(li, j);
|
||||
store_camera(shadow_mtx, light_data.shadow_matrices[j]);
|
||||
|
||||
Vector2 uv_scale = light_instance_get_shadow_uv_scale(li, j);
|
||||
uv_scale *= atlas_rect.size; //adapt to atlas size
|
||||
switch (j) {
|
||||
case 0: {
|
||||
light_data.uv_scale1[0] = uv_scale.x;
|
||||
light_data.uv_scale1[1] = uv_scale.y;
|
||||
} break;
|
||||
case 1: {
|
||||
light_data.uv_scale2[0] = uv_scale.x;
|
||||
light_data.uv_scale2[1] = uv_scale.y;
|
||||
} break;
|
||||
case 2: {
|
||||
light_data.uv_scale3[0] = uv_scale.x;
|
||||
light_data.uv_scale3[1] = uv_scale.y;
|
||||
} break;
|
||||
case 3: {
|
||||
light_data.uv_scale4[0] = uv_scale.x;
|
||||
light_data.uv_scale4[1] = uv_scale.y;
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
float fade_start = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_FADE_START);
|
||||
light_data.fade_from = -light_data.shadow_split_offsets[3] * MIN(fade_start, 0.999); //using 1.0 would break smoothstep
|
||||
light_data.fade_to = -light_data.shadow_split_offsets[3];
|
||||
|
||||
float softshadow_angle = storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
|
||||
if (softshadow_angle > 0.0) {
|
||||
// I know tan(0) is 0, but let's not risk it with numerical precision.
|
||||
// technically this will keep expanding until reaching the sun, but all we care
|
||||
// is expand until we reach the radius of the near plane (there can't be more occluders than that)
|
||||
light_data.softshadow_angle = Math::tan(Math::deg2rad(softshadow_angle));
|
||||
} else {
|
||||
light_data.softshadow_angle = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Copy to SkyDirectionalLightData
|
||||
|
|
@ -1619,6 +1656,10 @@ void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_lig
|
|||
light_data.direction[1] = direction.y;
|
||||
light_data.direction[2] = direction.z;
|
||||
|
||||
float size = storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
|
||||
|
||||
light_data.size = size;
|
||||
|
||||
light_data.cone_attenuation_angle[0] = Math::make_half_float(storage->light_get_param(base, RS::LIGHT_PARAM_SPOT_ATTENUATION));
|
||||
float spot_angle = storage->light_get_param(base, RS::LIGHT_PARAM_SPOT_ANGLE);
|
||||
light_data.cone_attenuation_angle[1] = Math::make_half_float(Math::cos(Math::deg2rad(spot_angle)));
|
||||
|
|
@ -1646,6 +1687,7 @@ void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_lig
|
|||
shadow_texel_size *= light_instance_get_shadow_texel_size(li, p_shadow_atlas);
|
||||
|
||||
light_data.shadow_normal_bias = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS) * shadow_texel_size;
|
||||
|
||||
} else { //omni
|
||||
light_data.shadow_bias = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BIAS) * radius / 10.0;
|
||||
float shadow_texel_size = light_instance_get_shadow_texel_size(li, p_shadow_atlas);
|
||||
|
|
@ -1656,18 +1698,31 @@ void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_lig
|
|||
|
||||
Rect2 rect = light_instance_get_shadow_atlas_rect(li, p_shadow_atlas);
|
||||
|
||||
if (type == RS::LIGHT_OMNI) {
|
||||
|
||||
light_data.atlas_rect[0] = rect.position.x;
|
||||
light_data.atlas_rect[1] = rect.position.y;
|
||||
light_data.atlas_rect[2] = rect.size.width;
|
||||
light_data.atlas_rect[3] = rect.size.height * 0.5;
|
||||
light_data.atlas_rect[3] = rect.size.height;
|
||||
|
||||
if (type == RS::LIGHT_OMNI) {
|
||||
|
||||
light_data.atlas_rect[3] *= 0.5; //one paraboloid on top of another
|
||||
Transform proj = (p_camera_inverse_transform * light_transform).inverse();
|
||||
|
||||
store_transform(proj, light_data.shadow_matrix);
|
||||
|
||||
if (size > 0.0) {
|
||||
|
||||
light_data.soft_shadow_size = size;
|
||||
} else {
|
||||
light_data.soft_shadow_size = 0.0;
|
||||
}
|
||||
|
||||
} else if (type == RS::LIGHT_SPOT) {
|
||||
|
||||
//used for clamping in this light type
|
||||
light_data.atlas_rect[2] += light_data.atlas_rect[0];
|
||||
light_data.atlas_rect[3] += light_data.atlas_rect[1];
|
||||
|
||||
Transform modelview = (p_camera_inverse_transform * light_transform).inverse();
|
||||
CameraMatrix bias;
|
||||
bias.set_light_bias();
|
||||
|
|
@ -1676,6 +1731,14 @@ void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_lig
|
|||
|
||||
CameraMatrix shadow_mtx = rectm * bias * light_instance_get_shadow_camera(li, 0) * modelview;
|
||||
store_camera(shadow_mtx, light_data.shadow_matrix);
|
||||
|
||||
if (size > 0.0) {
|
||||
CameraMatrix cm = light_instance_get_shadow_camera(li, 0);
|
||||
float half_np = cm.get_z_near() * Math::tan(Math::deg2rad(spot_angle));
|
||||
light_data.soft_shadow_size = (size * 0.5 / radius) / (half_np / cm.get_z_near()) * rect.size.width;
|
||||
} else {
|
||||
light_data.soft_shadow_size = 0.0;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
light_data.shadow_color_enabled[3] = 0;
|
||||
|
|
|
|||
|
|
@ -254,17 +254,19 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
|
|||
float position[3];
|
||||
float inv_radius;
|
||||
float direction[3];
|
||||
float size;
|
||||
uint16_t attenuation_energy[2]; //16 bits attenuation, then energy
|
||||
uint8_t color_specular[4]; //rgb color, a specular (8 bit unorm)
|
||||
uint16_t cone_attenuation_angle[2]; // attenuation and angle, (16bit float)
|
||||
uint32_t mask;
|
||||
uint8_t shadow_color_enabled[4]; //shadow rgb color, a>0.5 enabled (8bit unorm)
|
||||
float atlas_rect[4]; // in omni, used for atlas uv, in spot, used for projector uv
|
||||
float shadow_matrix[16];
|
||||
float shadow_bias;
|
||||
float shadow_normal_bias;
|
||||
float transmittance_bias;
|
||||
uint32_t pad;
|
||||
float soft_shadow_size;
|
||||
uint32_t mask;
|
||||
uint32_t pad[3];
|
||||
};
|
||||
|
||||
struct DirectionalLightData {
|
||||
|
|
@ -272,9 +274,11 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
|
|||
float direction[3];
|
||||
float energy;
|
||||
float color[3];
|
||||
float size;
|
||||
float specular;
|
||||
uint32_t mask;
|
||||
uint32_t pad[3];
|
||||
float softshadow_angle;
|
||||
uint32_t pad[1];
|
||||
uint32_t blend_splits;
|
||||
uint32_t shadow_enabled;
|
||||
float fade_from;
|
||||
|
|
@ -283,12 +287,17 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
|
|||
float shadow_normal_bias[4];
|
||||
float shadow_transmittance_bias[4];
|
||||
float shadow_transmittance_z_scale[4];
|
||||
float shadow_range_begin[4];
|
||||
float shadow_split_offsets[4];
|
||||
float shadow_matrices[4][16];
|
||||
float shadow_color1[4];
|
||||
float shadow_color2[4];
|
||||
float shadow_color3[4];
|
||||
float shadow_color4[4];
|
||||
float uv_scale1[2];
|
||||
float uv_scale2[2];
|
||||
float uv_scale3[2];
|
||||
float uv_scale4[2];
|
||||
};
|
||||
|
||||
struct GIProbeData {
|
||||
|
|
@ -343,6 +352,9 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
|
|||
uint32_t pancake_shadows;
|
||||
uint32_t shadow_filter_mode;
|
||||
|
||||
uint32_t shadow_blocker_count;
|
||||
uint32_t shadow_pad[3];
|
||||
|
||||
float ambient_light_color_energy[4];
|
||||
|
||||
float ambient_color_sky_mix;
|
||||
|
|
|
|||
|
|
@ -2032,7 +2032,7 @@ void RasterizerSceneRD::light_instance_set_transform(RID p_light_instance, const
|
|||
light_instance->transform = p_transform;
|
||||
}
|
||||
|
||||
void RasterizerSceneRD::light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale) {
|
||||
void RasterizerSceneRD::light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale, float p_range_begin, const Vector2 &p_uv_scale) {
|
||||
|
||||
LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
|
||||
ERR_FAIL_COND(!light_instance);
|
||||
|
|
@ -2048,7 +2048,9 @@ void RasterizerSceneRD::light_instance_set_shadow_transform(RID p_light_instance
|
|||
light_instance->shadow_transform[p_pass].farplane = p_far;
|
||||
light_instance->shadow_transform[p_pass].split = p_split;
|
||||
light_instance->shadow_transform[p_pass].bias_scale = p_bias_scale;
|
||||
light_instance->shadow_transform[p_pass].range_begin = p_range_begin;
|
||||
light_instance->shadow_transform[p_pass].shadow_texel_size = p_shadow_texel_size;
|
||||
light_instance->shadow_transform[p_pass].uv_scale = p_uv_scale;
|
||||
}
|
||||
|
||||
void RasterizerSceneRD::light_instance_mark_visible(RID p_light_instance) {
|
||||
|
|
|
|||
|
|
@ -573,7 +573,9 @@ private:
|
|||
float split;
|
||||
float bias_scale;
|
||||
float shadow_texel_size;
|
||||
float range_begin;
|
||||
Rect2 atlas_rect;
|
||||
Vector2 uv_scale;
|
||||
};
|
||||
|
||||
RS::LightType light_type = RS::LIGHT_DIRECTIONAL;
|
||||
|
|
@ -883,7 +885,7 @@ public:
|
|||
|
||||
RID light_instance_create(RID p_light);
|
||||
void light_instance_set_transform(RID p_light_instance, const Transform &p_transform);
|
||||
void light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale = 1.0);
|
||||
void light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale = 1.0, float p_range_begin = 0, const Vector2 &p_uv_scale = Vector2());
|
||||
void light_instance_mark_visible(RID p_light_instance);
|
||||
|
||||
_FORCE_INLINE_ RID light_instance_get_base_light(RID p_light_instance) {
|
||||
|
|
@ -967,6 +969,17 @@ public:
|
|||
LightInstance *li = light_instance_owner.getornull(p_light_instance);
|
||||
return li->shadow_transform[p_index].farplane;
|
||||
}
|
||||
_FORCE_INLINE_ float light_instance_get_shadow_range_begin(RID p_light_instance, int p_index) {
|
||||
|
||||
LightInstance *li = light_instance_owner.getornull(p_light_instance);
|
||||
return li->shadow_transform[p_index].range_begin;
|
||||
}
|
||||
|
||||
_FORCE_INLINE_ Vector2 light_instance_get_shadow_uv_scale(RID p_light_instance, int p_index) {
|
||||
|
||||
LightInstance *li = light_instance_owner.getornull(p_light_instance);
|
||||
return li->shadow_transform[p_index].uv_scale;
|
||||
}
|
||||
|
||||
_FORCE_INLINE_ Rect2 light_instance_get_directional_shadow_atlas_rect(RID p_light_instance, int p_index) {
|
||||
|
||||
|
|
|
|||
|
|
@ -3104,6 +3104,7 @@ RID RasterizerStorageRD::light_create(RS::LightType p_type) {
|
|||
light.param[RS::LIGHT_PARAM_INDIRECT_ENERGY] = 1.0;
|
||||
light.param[RS::LIGHT_PARAM_SPECULAR] = 0.5;
|
||||
light.param[RS::LIGHT_PARAM_RANGE] = 1.0;
|
||||
light.param[RS::LIGHT_PARAM_SIZE] = 0.0;
|
||||
light.param[RS::LIGHT_PARAM_SPOT_ANGLE] = 45;
|
||||
light.param[RS::LIGHT_PARAM_SHADOW_MAX_DISTANCE] = 0;
|
||||
light.param[RS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET] = 0.1;
|
||||
|
|
|
|||
|
|
@ -441,7 +441,7 @@ vec3 F0(float metallic, float specular, vec3 albedo) {
|
|||
return mix(vec3(dielectric), albedo, vec3(metallic));
|
||||
}
|
||||
|
||||
void light_compute(vec3 N, vec3 L, vec3 V, vec3 light_color, float attenuation, vec3 shadow_attenuation, vec3 diffuse_color, float roughness, float metallic, float specular, float specular_blob_intensity,
|
||||
void light_compute(vec3 N, vec3 L, vec3 V, float A, vec3 light_color, float attenuation, vec3 shadow_attenuation, vec3 diffuse_color, float roughness, float metallic, float specular, float specular_blob_intensity,
|
||||
#ifdef LIGHT_BACKLIGHT_USED
|
||||
vec3 backlight,
|
||||
#endif
|
||||
|
|
@ -481,7 +481,7 @@ LIGHT_SHADER_CODE
|
|||
/* clang-format on */
|
||||
|
||||
#else
|
||||
float NdotL = dot(N, L);
|
||||
float NdotL = min(A + dot(N, L), 1.0);
|
||||
float cNdotL = max(NdotL, 0.0); // clamped NdotL
|
||||
float NdotV = dot(N, V);
|
||||
float cNdotV = max(NdotV, 0.0);
|
||||
|
|
@ -491,11 +491,11 @@ LIGHT_SHADER_CODE
|
|||
#endif
|
||||
|
||||
#if defined(SPECULAR_BLINN) || defined(SPECULAR_SCHLICK_GGX) || defined(LIGHT_CLEARCOAT_USED)
|
||||
float cNdotH = max(dot(N, H), 0.0);
|
||||
float cNdotH = clamp(A + dot(N, H), 0.0, 1.0);
|
||||
#endif
|
||||
|
||||
#if defined(DIFFUSE_BURLEY) || defined(SPECULAR_SCHLICK_GGX) || defined(LIGHT_CLEARCOAT_USED)
|
||||
float cLdotH = max(dot(L, H), 0.0);
|
||||
float cLdotH = clamp(A + dot(L, H), 0.0, 1.0);
|
||||
#endif
|
||||
|
||||
if (metallic < 1.0) {
|
||||
|
|
@ -613,7 +613,7 @@ LIGHT_SHADER_CODE
|
|||
#elif defined(SPECULAR_PHONG)
|
||||
|
||||
vec3 R = normalize(-reflect(L, N));
|
||||
float cRdotV = max(0.0, dot(R, V));
|
||||
float cRdotV = clamp(A + dot(R, V), 0.0, 1.0);
|
||||
float shininess = exp2(15.0 * (1.0 - roughness) + 1.0) * 0.25;
|
||||
float phong = pow(cRdotV, shininess);
|
||||
phong *= (shininess + 8.0) * (1.0 / (8.0 * M_PI));
|
||||
|
|
@ -686,6 +686,24 @@ LIGHT_SHADER_CODE
|
|||
|
||||
#ifndef USE_NO_SHADOWS
|
||||
|
||||
const vec2 shadow_poisson_disk[16] = vec2[](
|
||||
vec2(-0.94201624, -0.39906216),
|
||||
vec2(0.94558609, -0.76890725),
|
||||
vec2(-0.094184101, -0.92938870),
|
||||
vec2(0.34495938, 0.29387760),
|
||||
vec2(-0.91588581, 0.45771432),
|
||||
vec2(-0.81544232, -0.87912464),
|
||||
vec2(-0.38277543, 0.27676845),
|
||||
vec2(0.97484398, 0.75648379),
|
||||
vec2(0.44323325, -0.97511554),
|
||||
vec2(0.53742981, -0.47373420),
|
||||
vec2(-0.26496911, -0.41893023),
|
||||
vec2(0.79197514, 0.19090188),
|
||||
vec2(-0.24188840, 0.99706507),
|
||||
vec2(-0.81409955, 0.91437590),
|
||||
vec2(0.19984126, 0.78641367),
|
||||
vec2(0.14383161, -0.14100790));
|
||||
|
||||
float sample_shadow(texture2D shadow, vec2 shadow_pixel_size, vec4 coord) {
|
||||
|
||||
vec2 pos = coord.xy;
|
||||
|
|
@ -725,6 +743,51 @@ float sample_shadow(texture2D shadow, vec2 shadow_pixel_size, vec4 coord) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
float sample_directional_soft_shadow(texture2D shadow, vec3 pssm_coord, vec2 tex_scale) {
|
||||
|
||||
//find blocker
|
||||
float blocker_count = 0.0;
|
||||
float blocker_average = 0.0;
|
||||
|
||||
mat2 poisson_rotate;
|
||||
|
||||
{
|
||||
float r = dot(vec2(gl_FragCoord.xy), vec2(131.234, 583.123));
|
||||
float sr = sin(r);
|
||||
float cr = cos(r);
|
||||
poisson_rotate = mat2(vec2(cr, -sr), vec2(sr, cr));
|
||||
}
|
||||
|
||||
for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
|
||||
vec2 suv = pssm_coord.xy + (poisson_rotate * shadow_poisson_disk[i]) * tex_scale;
|
||||
float d = textureLod(sampler2D(shadow, material_samplers[SAMPLER_LINEAR_CLAMP]), suv, 0.0).r;
|
||||
if (d < pssm_coord.z) {
|
||||
blocker_average += d;
|
||||
blocker_count += 1.0;
|
||||
}
|
||||
}
|
||||
|
||||
if (blocker_count > 0.0) {
|
||||
|
||||
//blockers found, do soft shadow
|
||||
blocker_average /= blocker_count;
|
||||
float penumbra = (pssm_coord.z - blocker_average) / blocker_average;
|
||||
tex_scale *= penumbra;
|
||||
|
||||
float s = 0.0;
|
||||
for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
|
||||
vec2 suv = pssm_coord.xy + (poisson_rotate * shadow_poisson_disk[i]) * tex_scale;
|
||||
s += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(suv, pssm_coord.z, 1.0));
|
||||
}
|
||||
|
||||
return s / float(scene_data.shadow_blocker_count);
|
||||
|
||||
} else {
|
||||
//no blockers found, so no shadow
|
||||
return 1.0;
|
||||
}
|
||||
}
|
||||
|
||||
#endif //USE_NO_SHADOWS
|
||||
|
||||
void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 albedo, float roughness, float metallic, float specular, float p_blob_intensity,
|
||||
|
|
@ -760,6 +823,13 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
|
|||
vec3 shadow_attenuation = vec3(1.0);
|
||||
vec4 color_specular = unpackUnorm4x8(lights.data[idx].color_specular);
|
||||
color_specular.rgb *= attenuation_energy.y;
|
||||
float size_A = 0.0;
|
||||
|
||||
if (lights.data[idx].size > 0.0) {
|
||||
|
||||
float t = lights.data[idx].size / max(0.001, light_length);
|
||||
size_A = max(0.0, 1.0 - 1 / sqrt(1 + t * t));
|
||||
}
|
||||
|
||||
#ifdef LIGHT_TRANSMITTANCE_USED
|
||||
float transmittance_z = transmittance_depth; //no transmittance by default
|
||||
|
|
@ -773,7 +843,7 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
|
|||
vec4 v = vec4(vertex, 1.0);
|
||||
|
||||
vec4 splane = (lights.data[idx].shadow_matrix * v);
|
||||
float shadow_len = length(splane.xyz);
|
||||
float shadow_len = length(splane.xyz); //need to remember shadow len from here
|
||||
|
||||
{
|
||||
vec3 nofs = normal_interp * lights.data[idx].shadow_normal_bias / lights.data[idx].inv_radius;
|
||||
|
|
@ -782,6 +852,105 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
|
|||
splane = (lights.data[idx].shadow_matrix * v);
|
||||
}
|
||||
|
||||
float shadow;
|
||||
|
||||
if (lights.data[idx].soft_shadow_size > 0.0) {
|
||||
//soft shadow
|
||||
|
||||
//find blocker
|
||||
|
||||
float blocker_count = 0.0;
|
||||
float blocker_average = 0.0;
|
||||
|
||||
mat2 poisson_rotate;
|
||||
|
||||
{
|
||||
float r = dot(vec2(gl_FragCoord.xy), vec2(131.234, 583.123));
|
||||
float sr = sin(r);
|
||||
float cr = cos(r);
|
||||
poisson_rotate = mat2(vec2(cr, -sr), vec2(sr, cr));
|
||||
}
|
||||
|
||||
vec3 normal = normalize(splane.xyz);
|
||||
vec3 v0 = abs(normal.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
|
||||
vec3 tangent = normalize(cross(v0, normal));
|
||||
vec3 bitangent = normalize(cross(tangent, normal));
|
||||
float z_norm = shadow_len * lights.data[idx].inv_radius;
|
||||
|
||||
tangent *= lights.data[idx].soft_shadow_size;
|
||||
bitangent *= lights.data[idx].soft_shadow_size;
|
||||
|
||||
for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
|
||||
vec2 poisson = (poisson_rotate * shadow_poisson_disk[i]);
|
||||
vec3 pos = splane.xyz + tangent * poisson.x + bitangent * poisson.y;
|
||||
|
||||
pos = normalize(pos);
|
||||
vec4 uv_rect = lights.data[idx].atlas_rect;
|
||||
|
||||
if (pos.z >= 0.0) {
|
||||
|
||||
pos.z += 1.0;
|
||||
uv_rect.y += uv_rect.w;
|
||||
} else {
|
||||
|
||||
pos.z = 1.0 - pos.z;
|
||||
}
|
||||
|
||||
pos.xy /= pos.z;
|
||||
|
||||
pos.xy = pos.xy * 0.5 + 0.5;
|
||||
pos.xy = uv_rect.xy + pos.xy * uv_rect.zw;
|
||||
|
||||
float d = textureLod(sampler2D(shadow_atlas, material_samplers[SAMPLER_LINEAR_CLAMP]), pos.xy, 0.0).r;
|
||||
if (d < z_norm) {
|
||||
blocker_average += d;
|
||||
blocker_count += 1.0;
|
||||
}
|
||||
}
|
||||
|
||||
if (blocker_count > 0.0) {
|
||||
|
||||
//blockers found, do soft shadow
|
||||
blocker_average /= blocker_count;
|
||||
float penumbra = (z_norm - blocker_average) / blocker_average;
|
||||
tangent *= penumbra;
|
||||
bitangent *= penumbra;
|
||||
|
||||
z_norm -= lights.data[idx].inv_radius * lights.data[idx].shadow_bias;
|
||||
|
||||
shadow = 0.0;
|
||||
for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
|
||||
|
||||
vec2 poisson = (poisson_rotate * shadow_poisson_disk[i]);
|
||||
vec3 pos = splane.xyz + tangent * poisson.x + bitangent * poisson.y;
|
||||
|
||||
pos = normalize(pos);
|
||||
vec4 uv_rect = lights.data[idx].atlas_rect;
|
||||
|
||||
if (pos.z >= 0.0) {
|
||||
|
||||
pos.z += 1.0;
|
||||
uv_rect.y += uv_rect.w;
|
||||
} else {
|
||||
|
||||
pos.z = 1.0 - pos.z;
|
||||
}
|
||||
|
||||
pos.xy /= pos.z;
|
||||
|
||||
pos.xy = pos.xy * 0.5 + 0.5;
|
||||
pos.xy = uv_rect.xy + pos.xy * uv_rect.zw;
|
||||
shadow += textureProj(sampler2DShadow(shadow_atlas, shadow_sampler), vec4(pos.xy, z_norm, 1.0));
|
||||
}
|
||||
|
||||
shadow /= float(scene_data.shadow_blocker_count);
|
||||
|
||||
} else {
|
||||
//no blockers found, so no shadow
|
||||
shadow = 1.0;
|
||||
}
|
||||
} else {
|
||||
|
||||
splane.xyz = normalize(splane.xyz);
|
||||
vec4 clamp_rect = lights.data[idx].atlas_rect;
|
||||
|
||||
|
|
@ -801,7 +970,8 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
|
|||
splane.z = (shadow_len - lights.data[idx].shadow_bias) * lights.data[idx].inv_radius;
|
||||
splane.xy = clamp_rect.xy + splane.xy * clamp_rect.zw;
|
||||
splane.w = 1.0; //needed? i think it should be 1 already
|
||||
float shadow = sample_shadow(shadow_atlas, scene_data.shadow_atlas_pixel_size, splane);
|
||||
shadow = sample_shadow(shadow_atlas, scene_data.shadow_atlas_pixel_size, splane);
|
||||
}
|
||||
|
||||
#ifdef LIGHT_TRANSMITTANCE_USED
|
||||
{
|
||||
|
|
@ -836,7 +1006,7 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
|
|||
}
|
||||
#endif //USE_NO_SHADOWS
|
||||
|
||||
light_compute(normal, normalize(light_rel_vec), eye_vec, color_specular.rgb, light_attenuation, shadow_attenuation, albedo, roughness, metallic, specular, color_specular.a * p_blob_intensity,
|
||||
light_compute(normal, normalize(light_rel_vec), eye_vec, size_A, color_specular.rgb, light_attenuation, shadow_attenuation, albedo, roughness, metallic, specular, color_specular.a * p_blob_intensity,
|
||||
#ifdef LIGHT_BACKLIGHT_USED
|
||||
backlight,
|
||||
#endif
|
||||
|
|
@ -903,6 +1073,13 @@ void light_process_spot(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
|
|||
vec4 color_specular = unpackUnorm4x8(lights.data[idx].color_specular);
|
||||
color_specular.rgb *= attenuation_energy.y;
|
||||
|
||||
float size_A = 0.0;
|
||||
|
||||
if (lights.data[idx].size > 0.0) {
|
||||
|
||||
float t = lights.data[idx].size / max(0.001, light_length);
|
||||
size_A = max(0.0, 1.0 - 1 / sqrt(1 + t * t));
|
||||
}
|
||||
/*
|
||||
if (lights.data[idx].atlas_rect!=vec4(0.0)) {
|
||||
//use projector texture
|
||||
|
|
@ -920,22 +1097,82 @@ void light_process_spot(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
|
|||
|
||||
v.xyz -= spot_dir * lights.data[idx].shadow_bias;
|
||||
|
||||
float depth_bias_scale = 1.0 / (max(0.0001, dot(spot_dir, -light_rel_vec) * lights.data[idx].inv_radius)); //the closer to the light origin, the more you have to offset to reach 1px in the map
|
||||
float z_norm = dot(spot_dir, -light_rel_vec) * lights.data[idx].inv_radius;
|
||||
|
||||
float depth_bias_scale = 1.0 / (max(0.0001, z_norm)); //the closer to the light origin, the more you have to offset to reach 1px in the map
|
||||
vec3 normal_bias = normalize(normal_interp) * (1.0 - max(0.0, dot(spot_dir, -normalize(normal_interp)))) * lights.data[idx].shadow_normal_bias * depth_bias_scale;
|
||||
normal_bias -= spot_dir * dot(spot_dir, normal_bias); //only XY, no Z
|
||||
v.xyz += normal_bias;
|
||||
|
||||
//adjust with bias
|
||||
z_norm = dot(spot_dir, v.xyz - lights.data[idx].position) * lights.data[idx].inv_radius;
|
||||
|
||||
float shadow;
|
||||
|
||||
vec4 splane = (lights.data[idx].shadow_matrix * v);
|
||||
splane /= splane.w;
|
||||
splane.z = dot(spot_dir, v.xyz - lights.data[idx].position) * lights.data[idx].inv_radius;
|
||||
float shadow = sample_shadow(shadow_atlas, scene_data.shadow_atlas_pixel_size, splane);
|
||||
|
||||
if (lights.data[idx].soft_shadow_size > 0.0) {
|
||||
//soft shadow
|
||||
|
||||
//find blocker
|
||||
|
||||
float blocker_count = 0.0;
|
||||
float blocker_average = 0.0;
|
||||
|
||||
mat2 poisson_rotate;
|
||||
|
||||
{
|
||||
float r = dot(vec2(gl_FragCoord.xy), vec2(131.234, 583.123));
|
||||
float sr = sin(r);
|
||||
float cr = cos(r);
|
||||
poisson_rotate = mat2(vec2(cr, -sr), vec2(sr, cr));
|
||||
}
|
||||
|
||||
float uv_size = lights.data[idx].soft_shadow_size * z_norm;
|
||||
for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
|
||||
vec2 suv = splane.xy + (poisson_rotate * shadow_poisson_disk[i]) * uv_size;
|
||||
suv = clamp(suv, lights.data[idx].atlas_rect.xy, lights.data[idx].atlas_rect.zw);
|
||||
float d = textureLod(sampler2D(shadow_atlas, material_samplers[SAMPLER_LINEAR_CLAMP]), suv, 0.0).r;
|
||||
if (d < z_norm) {
|
||||
blocker_average += d;
|
||||
blocker_count += 1.0;
|
||||
}
|
||||
}
|
||||
|
||||
if (blocker_count > 0.0) {
|
||||
|
||||
//blockers found, do soft shadow
|
||||
blocker_average /= blocker_count;
|
||||
float penumbra = (z_norm - blocker_average) / blocker_average;
|
||||
uv_size *= penumbra;
|
||||
|
||||
shadow = 0.0;
|
||||
for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
|
||||
vec2 suv = splane.xy + (poisson_rotate * shadow_poisson_disk[i]) * uv_size;
|
||||
suv = clamp(suv, lights.data[idx].atlas_rect.xy, lights.data[idx].atlas_rect.zw);
|
||||
shadow += textureProj(sampler2DShadow(shadow_atlas, shadow_sampler), vec4(suv, z_norm, 1.0));
|
||||
}
|
||||
|
||||
shadow /= float(scene_data.shadow_blocker_count);
|
||||
|
||||
} else {
|
||||
//no blockers found, so no shadow
|
||||
shadow = 1.0;
|
||||
}
|
||||
|
||||
} else {
|
||||
//hard shadow
|
||||
splane.z = z_norm;
|
||||
shadow = sample_shadow(shadow_atlas, scene_data.shadow_atlas_pixel_size, splane);
|
||||
}
|
||||
|
||||
shadow_attenuation = mix(shadow_color_enabled.rgb, vec3(1.0), shadow);
|
||||
|
||||
#ifdef LIGHT_TRANSMITTANCE_USED
|
||||
{
|
||||
|
||||
splane = (lights.data[idx].shadow_matrix * vec4(vertex - normalize(normal_interp) * lights.data[idx].transmittance_bias, 1.0));
|
||||
vec4 splane = (lights.data[idx].shadow_matrix * vec4(vertex - normalize(normal_interp) * lights.data[idx].transmittance_bias, 1.0));
|
||||
splane /= splane.w;
|
||||
|
||||
float shadow_z = textureLod(sampler2D(shadow_atlas, material_samplers[SAMPLER_LINEAR_CLAMP]), splane.xy, 0.0).r;
|
||||
|
|
@ -950,7 +1187,7 @@ void light_process_spot(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
|
|||
|
||||
#endif //USE_NO_SHADOWS
|
||||
|
||||
light_compute(normal, normalize(light_rel_vec), eye_vec, color_specular.rgb, light_attenuation, shadow_attenuation, albedo, roughness, metallic, specular, color_specular.a * p_blob_intensity,
|
||||
light_compute(normal, normalize(light_rel_vec), eye_vec, size_A, color_specular.rgb, light_attenuation, shadow_attenuation, albedo, roughness, metallic, specular, color_specular.a * p_blob_intensity,
|
||||
#ifdef LIGHT_BACKLIGHT_USED
|
||||
backlight,
|
||||
#endif
|
||||
|
|
@ -1636,13 +1873,28 @@ FRAGMENT_SHADER_CODE
|
|||
normal_bias -= light_dir * dot(light_dir, normal_bias); \
|
||||
m_var.xyz += normal_bias;
|
||||
|
||||
float shadow = 0.0;
|
||||
|
||||
if (depth_z < directional_lights.data[i].shadow_split_offsets.x) {
|
||||
vec4 v = vec4(vertex, 1.0);
|
||||
|
||||
BIAS_FUNC(v, 0)
|
||||
|
||||
pssm_coord = (directional_lights.data[i].shadow_matrix1 * v);
|
||||
pssm_coord /= pssm_coord.w;
|
||||
|
||||
if (directional_lights.data[i].softshadow_angle > 0) {
|
||||
float range_pos = dot(directional_lights.data[i].direction, v.xyz);
|
||||
float range_begin = directional_lights.data[i].shadow_range_begin.x;
|
||||
float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
|
||||
vec2 tex_scale = directional_lights.data[i].uv_scale1 * test_radius;
|
||||
shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
|
||||
} else {
|
||||
shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
|
||||
}
|
||||
|
||||
shadow_color = directional_lights.data[i].shadow_color1.rgb;
|
||||
|
||||
#ifdef LIGHT_TRANSMITTANCE_USED
|
||||
{
|
||||
vec4 trans_vertex = vec4(vertex - normalize(normal_interp) * directional_lights.data[i].shadow_transmittance_bias.x, 1.0);
|
||||
|
|
@ -1663,6 +1915,18 @@ FRAGMENT_SHADER_CODE
|
|||
BIAS_FUNC(v, 1)
|
||||
|
||||
pssm_coord = (directional_lights.data[i].shadow_matrix2 * v);
|
||||
pssm_coord /= pssm_coord.w;
|
||||
|
||||
if (directional_lights.data[i].softshadow_angle > 0) {
|
||||
float range_pos = dot(directional_lights.data[i].direction, v.xyz);
|
||||
float range_begin = directional_lights.data[i].shadow_range_begin.y;
|
||||
float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
|
||||
vec2 tex_scale = directional_lights.data[i].uv_scale2 * test_radius;
|
||||
shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
|
||||
} else {
|
||||
shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
|
||||
}
|
||||
|
||||
shadow_color = directional_lights.data[i].shadow_color2.rgb;
|
||||
#ifdef LIGHT_TRANSMITTANCE_USED
|
||||
{
|
||||
|
|
@ -1684,6 +1948,18 @@ FRAGMENT_SHADER_CODE
|
|||
BIAS_FUNC(v, 2)
|
||||
|
||||
pssm_coord = (directional_lights.data[i].shadow_matrix3 * v);
|
||||
pssm_coord /= pssm_coord.w;
|
||||
|
||||
if (directional_lights.data[i].softshadow_angle > 0) {
|
||||
float range_pos = dot(directional_lights.data[i].direction, v.xyz);
|
||||
float range_begin = directional_lights.data[i].shadow_range_begin.z;
|
||||
float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
|
||||
vec2 tex_scale = directional_lights.data[i].uv_scale3 * test_radius;
|
||||
shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
|
||||
} else {
|
||||
shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
|
||||
}
|
||||
|
||||
shadow_color = directional_lights.data[i].shadow_color3.rgb;
|
||||
#ifdef LIGHT_TRANSMITTANCE_USED
|
||||
{
|
||||
|
|
@ -1706,7 +1982,20 @@ FRAGMENT_SHADER_CODE
|
|||
BIAS_FUNC(v, 3)
|
||||
|
||||
pssm_coord = (directional_lights.data[i].shadow_matrix4 * v);
|
||||
pssm_coord /= pssm_coord.w;
|
||||
|
||||
if (directional_lights.data[i].softshadow_angle > 0) {
|
||||
float range_pos = dot(directional_lights.data[i].direction, v.xyz);
|
||||
float range_begin = directional_lights.data[i].shadow_range_begin.w;
|
||||
float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
|
||||
vec2 tex_scale = directional_lights.data[i].uv_scale4 * test_radius;
|
||||
shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
|
||||
} else {
|
||||
shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
|
||||
}
|
||||
|
||||
shadow_color = directional_lights.data[i].shadow_color4.rgb;
|
||||
|
||||
#ifdef LIGHT_TRANSMITTANCE_USED
|
||||
{
|
||||
vec4 trans_vertex = vec4(vertex - normalize(normal_interp) * directional_lights.data[i].shadow_transmittance_bias.w, 1.0);
|
||||
|
|
@ -1722,40 +2011,72 @@ FRAGMENT_SHADER_CODE
|
|||
#endif
|
||||
}
|
||||
|
||||
pssm_coord /= pssm_coord.w;
|
||||
|
||||
float shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
|
||||
|
||||
if (directional_lights.data[i].blend_splits) {
|
||||
|
||||
vec3 shadow_color_blend = vec3(0.0);
|
||||
float pssm_blend;
|
||||
float shadow2;
|
||||
|
||||
if (depth_z < directional_lights.data[i].shadow_split_offsets.x) {
|
||||
vec4 v = vec4(vertex, 1.0);
|
||||
BIAS_FUNC(v, 1)
|
||||
pssm_coord = (directional_lights.data[i].shadow_matrix2 * v);
|
||||
pssm_coord /= pssm_coord.w;
|
||||
|
||||
if (directional_lights.data[i].softshadow_angle > 0) {
|
||||
float range_pos = dot(directional_lights.data[i].direction, v.xyz);
|
||||
float range_begin = directional_lights.data[i].shadow_range_begin.y;
|
||||
float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
|
||||
vec2 tex_scale = directional_lights.data[i].uv_scale2 * test_radius;
|
||||
shadow2 = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
|
||||
} else {
|
||||
shadow2 = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
|
||||
}
|
||||
|
||||
pssm_blend = smoothstep(0.0, directional_lights.data[i].shadow_split_offsets.x, depth_z);
|
||||
shadow_color_blend = directional_lights.data[i].shadow_color2.rgb;
|
||||
} else if (depth_z < directional_lights.data[i].shadow_split_offsets.y) {
|
||||
vec4 v = vec4(vertex, 1.0);
|
||||
BIAS_FUNC(v, 2)
|
||||
pssm_coord = (directional_lights.data[i].shadow_matrix3 * v);
|
||||
pssm_coord /= pssm_coord.w;
|
||||
|
||||
if (directional_lights.data[i].softshadow_angle > 0) {
|
||||
float range_pos = dot(directional_lights.data[i].direction, v.xyz);
|
||||
float range_begin = directional_lights.data[i].shadow_range_begin.z;
|
||||
float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
|
||||
vec2 tex_scale = directional_lights.data[i].uv_scale3 * test_radius;
|
||||
shadow2 = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
|
||||
} else {
|
||||
shadow2 = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
|
||||
}
|
||||
|
||||
pssm_blend = smoothstep(directional_lights.data[i].shadow_split_offsets.x, directional_lights.data[i].shadow_split_offsets.y, depth_z);
|
||||
|
||||
shadow_color_blend = directional_lights.data[i].shadow_color3.rgb;
|
||||
} else if (depth_z < directional_lights.data[i].shadow_split_offsets.z) {
|
||||
vec4 v = vec4(vertex, 1.0);
|
||||
BIAS_FUNC(v, 3)
|
||||
pssm_coord = (directional_lights.data[i].shadow_matrix4 * v);
|
||||
pssm_coord /= pssm_coord.w;
|
||||
if (directional_lights.data[i].softshadow_angle > 0) {
|
||||
float range_pos = dot(directional_lights.data[i].direction, v.xyz);
|
||||
float range_begin = directional_lights.data[i].shadow_range_begin.w;
|
||||
float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
|
||||
vec2 tex_scale = directional_lights.data[i].uv_scale4 * test_radius;
|
||||
shadow2 = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
|
||||
} else {
|
||||
shadow2 = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
|
||||
}
|
||||
|
||||
pssm_blend = smoothstep(directional_lights.data[i].shadow_split_offsets.y, directional_lights.data[i].shadow_split_offsets.z, depth_z);
|
||||
shadow_color_blend = directional_lights.data[i].shadow_color4.rgb;
|
||||
} else {
|
||||
pssm_blend = 0.0; //if no blend, same coord will be used (divide by z will result in same value, and already cached)
|
||||
}
|
||||
|
||||
pssm_coord /= pssm_coord.w;
|
||||
pssm_blend = sqrt(pssm_blend);
|
||||
|
||||
float shadow2 = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
|
||||
shadow = mix(shadow, shadow2, pssm_blend);
|
||||
shadow_color = mix(shadow_color, shadow_color_blend, pssm_blend);
|
||||
}
|
||||
|
|
@ -1767,7 +2088,7 @@ FRAGMENT_SHADER_CODE
|
|||
#undef BIAS_FUNC
|
||||
}
|
||||
|
||||
light_compute(normal, directional_lights.data[i].direction, normalize(view), directional_lights.data[i].color * directional_lights.data[i].energy, 1.0, shadow_attenuation, albedo, roughness, metallic, specular, directional_lights.data[i].specular * specular_blob_intensity,
|
||||
light_compute(normal, directional_lights.data[i].direction, normalize(view), directional_lights.data[i].size, directional_lights.data[i].color * directional_lights.data[i].energy, 1.0, shadow_attenuation, albedo, roughness, metallic, specular, directional_lights.data[i].specular * specular_blob_intensity,
|
||||
#ifdef LIGHT_BACKLIGHT_USED
|
||||
backlight,
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -47,6 +47,11 @@ layout(set = 0, binding = 3, std140) uniform SceneData {
|
|||
bool pancake_shadows;
|
||||
uint shadow_filter_mode;
|
||||
|
||||
uint shadow_blocker_count;
|
||||
uint shadow_pad0;
|
||||
uint shadow_pad1;
|
||||
uint shadow_pad2;
|
||||
|
||||
vec4 ambient_light_color_energy;
|
||||
|
||||
float ambient_color_sky_mix;
|
||||
|
|
@ -141,17 +146,19 @@ struct LightData { //this structure needs to be as packed as possible
|
|||
vec3 position;
|
||||
float inv_radius;
|
||||
vec3 direction;
|
||||
float size;
|
||||
uint attenuation_energy; //attenuation
|
||||
uint color_specular; //rgb color, a specular (8 bit unorm)
|
||||
uint cone_attenuation_angle; // attenuation and angle, (16bit float)
|
||||
uint mask;
|
||||
uint shadow_color_enabled; //shadow rgb color, a>0.5 enabled (8bit unorm)
|
||||
vec4 atlas_rect; // used for spot
|
||||
mat4 shadow_matrix;
|
||||
float shadow_bias;
|
||||
float shadow_normal_bias;
|
||||
float transmittance_bias;
|
||||
uint pad;
|
||||
float soft_shadow_size; // for spot, it's the size in uv coordinates of the light, for omni it's the span angle
|
||||
uint mask;
|
||||
uint pad[3];
|
||||
};
|
||||
|
||||
layout(set = 0, binding = 5, std430) buffer Lights {
|
||||
|
|
@ -180,11 +187,11 @@ struct DirectionalLightData {
|
|||
vec3 direction;
|
||||
float energy;
|
||||
vec3 color;
|
||||
float size;
|
||||
float specular;
|
||||
uint mask;
|
||||
uint pad0;
|
||||
float softshadow_angle;
|
||||
uint pad1;
|
||||
uint pad2;
|
||||
bool blend_splits;
|
||||
bool shadow_enabled;
|
||||
float fade_from;
|
||||
|
|
@ -193,6 +200,7 @@ struct DirectionalLightData {
|
|||
vec4 shadow_normal_bias;
|
||||
vec4 shadow_transmittance_bias;
|
||||
vec4 shadow_transmittance_z_scale;
|
||||
vec4 shadow_range_begin;
|
||||
vec4 shadow_split_offsets;
|
||||
mat4 shadow_matrix1;
|
||||
mat4 shadow_matrix2;
|
||||
|
|
@ -202,6 +210,10 @@ struct DirectionalLightData {
|
|||
vec4 shadow_color2;
|
||||
vec4 shadow_color3;
|
||||
vec4 shadow_color4;
|
||||
vec2 uv_scale1;
|
||||
vec2 uv_scale2;
|
||||
vec2 uv_scale3;
|
||||
vec2 uv_scale4;
|
||||
};
|
||||
|
||||
layout(set = 0, binding = 7, std140) uniform DirectionalLights {
|
||||
|
|
|
|||
|
|
@ -1499,7 +1499,9 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
|
|||
if (j == 0 || d_z > z_max)
|
||||
z_max = d_z;
|
||||
}
|
||||
|
||||
real_t radius = 0;
|
||||
real_t soft_shadow_expand = 0;
|
||||
Vector3 center;
|
||||
|
||||
{
|
||||
|
|
@ -1528,12 +1530,30 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
|
|||
bias_scale = radius / first_radius;
|
||||
}
|
||||
|
||||
x_max_cam = x_vec.dot(center) + radius;
|
||||
x_min_cam = x_vec.dot(center) - radius;
|
||||
y_max_cam = y_vec.dot(center) + radius;
|
||||
y_min_cam = y_vec.dot(center) - radius;
|
||||
z_min_cam = z_vec.dot(center) - radius;
|
||||
|
||||
{
|
||||
|
||||
float soft_shadow_angle = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_SIZE);
|
||||
|
||||
if (soft_shadow_angle > 0.0 && pancake_size > 0.0) {
|
||||
|
||||
float z_range = (z_vec.dot(center) + radius + pancake_size) - z_min_cam;
|
||||
soft_shadow_expand = Math::tan(Math::deg2rad(soft_shadow_angle)) * z_range;
|
||||
|
||||
x_max += soft_shadow_expand;
|
||||
y_max += soft_shadow_expand;
|
||||
|
||||
x_min -= soft_shadow_expand;
|
||||
y_min -= soft_shadow_expand;
|
||||
}
|
||||
}
|
||||
|
||||
x_max_cam = x_vec.dot(center) + radius + soft_shadow_expand;
|
||||
x_min_cam = x_vec.dot(center) - radius - soft_shadow_expand;
|
||||
y_max_cam = y_vec.dot(center) + radius + soft_shadow_expand;
|
||||
y_min_cam = y_vec.dot(center) - radius - soft_shadow_expand;
|
||||
|
||||
if (depth_range_mode == RS::LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE) {
|
||||
//this trick here is what stabilizes the shadow (make potential jaggies to not move)
|
||||
//at the cost of some wasted resolution. Still the quality increase is very well worth it
|
||||
|
|
@ -1588,8 +1608,9 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
|
|||
}
|
||||
}
|
||||
|
||||
if (cull_max > z_max)
|
||||
if (cull_max > z_max) {
|
||||
z_max = cull_max;
|
||||
}
|
||||
|
||||
if (pancake_size > 0) {
|
||||
z_max = z_vec.dot(center) + radius + pancake_size;
|
||||
|
|
@ -1677,11 +1698,19 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
|
|||
|
||||
ortho_camera.set_orthogonal(-half_x, half_x, -half_y, half_y, 0, (z_max - z_min_cam));
|
||||
|
||||
Vector2 uv_scale(1.0 / (x_max_cam - x_min_cam), 1.0 / (y_max_cam - y_min_cam));
|
||||
|
||||
Transform ortho_transform;
|
||||
ortho_transform.basis = transform.basis;
|
||||
ortho_transform.origin = x_vec * (x_min_cam + half_x) + y_vec * (y_min_cam + half_y) + z_vec * z_max;
|
||||
|
||||
RSG::scene_render->light_instance_set_shadow_transform(light->instance, ortho_camera, ortho_transform, z_max - z_min_cam, distances[i + 1], i, radius * 2.0 / texture_size, bias_scale * aspect_bias_scale * min_distance_bias_scale);
|
||||
{
|
||||
Vector3 max_in_view = p_cam_transform.affine_inverse().xform(z_vec * cull_max);
|
||||
Vector3 dir_in_view = p_cam_transform.xform_inv(z_vec).normalized();
|
||||
cull_max = dir_in_view.dot(max_in_view);
|
||||
}
|
||||
|
||||
RSG::scene_render->light_instance_set_shadow_transform(light->instance, ortho_camera, ortho_transform, z_max - z_min_cam, distances[i + 1], i, radius * 2.0 / texture_size, bias_scale * aspect_bias_scale * min_distance_bias_scale, z_max, uv_scale);
|
||||
}
|
||||
|
||||
RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
|
||||
|
|
|
|||
|
|
@ -382,6 +382,7 @@ public:
|
|||
LIGHT_PARAM_INDIRECT_ENERGY,
|
||||
LIGHT_PARAM_SPECULAR,
|
||||
LIGHT_PARAM_RANGE,
|
||||
LIGHT_PARAM_SIZE,
|
||||
LIGHT_PARAM_ATTENUATION,
|
||||
LIGHT_PARAM_SPOT_ANGLE,
|
||||
LIGHT_PARAM_SPOT_ATTENUATION,
|
||||
|
|
|
|||
Loading…
Reference in New Issue