uniform mat4 m_ShadowViewProj;
uniform float f_shadowfar;
uniform float f_shadow_strength;
+ uniform vec4 CameraPos;
varying float normalOffsetScale;
varying float adj_shadow_strength;
varying float cosLight;
vec4 getPerspectiveFactor(in vec4 shadowPosition)
{
-
- float pDistance = length(shadowPosition.xy);
+ vec2 s = vec2(shadowPosition.x > CameraPos.x ? 1.0 : -1.0, shadowPosition.y > CameraPos.y ? 1.0 : -1.0);
+ vec2 l = s * (shadowPosition.xy - CameraPos.xy) / (1.0 - s * CameraPos.xy);
+ float pDistance = length(l);
float pFactor = pDistance * xyPerspectiveBias0 + xyPerspectiveBias1;
-
- shadowPosition.xyz *= vec3(vec2(1.0 / pFactor), zPerspectiveBias);
-
+ l /= pFactor;
+ shadowPosition.xy = CameraPos.xy * (1.0 - l) + s * l;
+ shadowPosition.z *= zPerspectiveBias;
return shadowPosition;
}
float getBaseLength(vec2 smTexCoord)
{
- float l = length(2.0 * smTexCoord.xy - 1.0); // length in texture coords
+ float l = length(2.0 * smTexCoord.xy - 1.0 - CameraPos.xy); // length in texture coords
return xyPerspectiveBias1 / (1.0 / l - xyPerspectiveBias0); // return to undistorted coords
}
float getDeltaPerspectiveFactor(float l)
{
- return 0.1 / (xyPerspectiveBias0 * l + xyPerspectiveBias1); // original distortion factor, divided by 10
+ return 0.04 * pow(512.0 / f_textureresolution, 0.4) / (xyPerspectiveBias0 * l + xyPerspectiveBias1); // original distortion factor, divided by 10
}
float getPenumbraRadius(sampler2D shadowsampler, vec2 smTexCoord, float realDistance, float multiplier)
float baseLength = getBaseLength(smTexCoord);
float perspectiveFactor;
- if (PCFBOUND == 0.0) return 0.0;
// Return fast if sharp shadows are requested
if (PCFBOUND == 0.0)
return 0.0;
vec3 shadow_color = vec3(0.0, 0.0, 0.0);
vec3 posLightSpace = getLightSpacePosition();
- float distance_rate = (1 - pow(clamp(2.0 * length(posLightSpace.xy - 0.5),0.0,1.0), 50.0));
+ float distance_rate = (1.0 - pow(clamp(2.0 * length(posLightSpace.xy - 0.5),0.0,1.0), 10.0));
+ if (max(abs(posLightSpace.x - 0.5), abs(posLightSpace.y - 0.5)) > 0.5)
+ distance_rate = 0.0;
float f_adj_shadow_strength = max(adj_shadow_strength-mtsmoothstep(0.9,1.1, posLightSpace.z),0.0);
if (distance_rate > 1e-7) {
-
+
#ifdef COLORED_SHADOWS
vec4 visibility;
if (cosLight > 0.0)
}
shadow_int *= f_adj_shadow_strength;
-
+
// calculate fragment color from components:
col.rgb =
adjusted_night_ratio * col.rgb + // artificial light
uniform float fogDistance;
uniform vec3 eyePosition;
+// The cameraOffset is the current center of the visible world.
+uniform vec3 cameraOffset;
+uniform float animationTimer;
+#ifdef ENABLE_DYNAMIC_SHADOWS
+ // shadow texture
+ uniform sampler2D ShadowMapSampler;
+ // shadow uniforms
+ uniform vec3 v_LightDirection;
+ uniform float f_textureresolution;
+ uniform mat4 m_ShadowViewProj;
+ uniform float f_shadowfar;
+ uniform float f_shadow_strength;
+ uniform vec4 CameraPos;
+ varying float normalOffsetScale;
+ varying float adj_shadow_strength;
+ varying float cosLight;
+ varying float f_normal_length;
+#endif
+
+
varying vec3 vNormal;
varying vec3 vPosition;
+// World position in the visible world (i.e. relative to the cameraOffset.)
+// This can be used for many shader effects without loss of precision.
+// If the absolute position is required it can be calculated with
+// cameraOffset + worldPosition (for large coordinates the limits of float
+// precision must be considered).
varying vec3 worldPosition;
varying lowp vec4 varColor;
#ifdef GL_ES
#else
centroid varying vec2 varTexCoord;
#endif
-
varying vec3 eyeVec;
varying float nightRatio;
varying float vIDiff;
-const float e = 2.718281828459;
-const float BS = 10.0;
const float fogStart = FOG_START;
const float fogShadingParameter = 1.0 / (1.0 - fogStart);
-#ifdef ENABLE_DYNAMIC_SHADOWS
- // shadow texture
- uniform sampler2D ShadowMapSampler;
- // shadow uniforms
- uniform vec3 v_LightDirection;
- uniform float f_textureresolution;
- uniform mat4 m_ShadowViewProj;
- uniform float f_shadowfar;
- uniform float f_timeofday;
- uniform float f_shadow_strength;
- varying float normalOffsetScale;
- varying float adj_shadow_strength;
- varying float cosLight;
- varying float f_normal_length;
-#endif
+
#ifdef ENABLE_DYNAMIC_SHADOWS
uniform float xyPerspectiveBias0;
vec4 getPerspectiveFactor(in vec4 shadowPosition)
{
-
- float pDistance = length(shadowPosition.xy);
+ vec2 s = vec2(shadowPosition.x > CameraPos.x ? 1.0 : -1.0, shadowPosition.y > CameraPos.y ? 1.0 : -1.0);
+ vec2 l = s * (shadowPosition.xy - CameraPos.xy) / (1.0 - s * CameraPos.xy);
+ float pDistance = length(l);
float pFactor = pDistance * xyPerspectiveBias0 + xyPerspectiveBias1;
-
- shadowPosition.xyz *= vec3(vec2(1.0 / pFactor), zPerspectiveBias);
-
+ l /= pFactor;
+ shadowPosition.xy = CameraPos.xy * (1.0 - l) + s * l;
+ shadowPosition.z *= zPerspectiveBias;
return shadowPosition;
}
+// assuming near is always 1.0
+float getLinearDepth()
+{
+ return 2.0 * f_shadowfar / (f_shadowfar + 1.0 - (2.0 * gl_FragCoord.z - 1.0) * (f_shadowfar - 1.0));
+}
+
vec3 getLightSpacePosition()
{
vec4 pLightSpace;
float getBaseLength(vec2 smTexCoord)
{
- float l = length(2.0 * smTexCoord.xy - 1.0); // length in texture coords
+ float l = length(2.0 * smTexCoord.xy - 1.0 - CameraPos.xy); // length in texture coords
return xyPerspectiveBias1 / (1.0 / l - xyPerspectiveBias0); // return to undistorted coords
}
float getDeltaPerspectiveFactor(float l)
{
- return 0.1 / (xyPerspectiveBias0 * l + xyPerspectiveBias1); // original distortion factor, divided by 10
+ return 0.04 * pow(512.0 / f_textureresolution, 0.4) / (xyPerspectiveBias0 * l + xyPerspectiveBias1); // original distortion factor, divided by 10
}
float getPenumbraRadius(sampler2D shadowsampler, vec2 smTexCoord, float realDistance, float multiplier)
// Return fast if sharp shadows are requested
if (PCFBOUND == 0.0)
return 0.0;
-
+
if (SOFTSHADOWRADIUS <= 1.0) {
perspectiveFactor = getDeltaPerspectiveFactor(baseLength);
return max(2 * length(smTexCoord.xy) * 2048 / f_textureresolution / pow(perspectiveFactor, 3), SOFTSHADOWRADIUS);
#endif
#if ENABLE_TONE_MAPPING
+
/* Hable's UC2 Tone mapping parameters
A = 0.22;
B = 0.30;
}
#endif
+
+
void main(void)
{
vec3 color;
vec2 uv = varTexCoord.st;
- vec4 base = texture2D(baseTexture, uv).rgba;
+ vec4 base = texture2D(baseTexture, uv).rgba;
// If alpha is zero, we can just discard the pixel. This fixes transparency
// on GPUs like GC7000L, where GL_ALPHA_TEST is not implemented in mesa,
// and also on GLES 2, where GL_ALPHA_TEST is missing entirely.
#endif
color = base.rgb;
- vec4 col = vec4(color.rgb, base.a);
- col.rgb *= varColor.rgb;
+ vec4 col = vec4(color.rgb * varColor.rgb, 1.0);
col.rgb *= vIDiff;
#ifdef ENABLE_DYNAMIC_SHADOWS
vec3 shadow_color = vec3(0.0, 0.0, 0.0);
vec3 posLightSpace = getLightSpacePosition();
- float distance_rate = (1 - pow(clamp(2.0 * length(posLightSpace.xy - 0.5),0.0,1.0), 50.0));
+ float distance_rate = (1.0 - pow(clamp(2.0 * length(posLightSpace.xy - 0.5),0.0,1.0), 10.0));
+ if (max(abs(posLightSpace.x - 0.5), abs(posLightSpace.y - 0.5)) > 0.5)
+ distance_rate = 0.0;
float f_adj_shadow_strength = max(adj_shadow_strength-mtsmoothstep(0.9,1.1, posLightSpace.z),0.0);
if (distance_rate > 1e-7) {
-
+
#ifdef COLORED_SHADOWS
vec4 visibility;
if (cosLight > 0.0)
// Power ratio was measured on torches in MTG (brightness = 14).
float adjusted_night_ratio = pow(max(0.0, nightRatio), 0.6);
- // cosine of the normal-to-light angle when
- // we start to apply self-shadowing
+ // Apply self-shadowing when light falls at a narrow angle to the surface
+ // Cosine of the cut-off angle.
const float self_shadow_cutoff_cosine = 0.14;
if (f_normal_length != 0 && cosLight < self_shadow_cutoff_cosine) {
shadow_int = max(shadow_int, 1 - clamp(cosLight, 0.0, self_shadow_cutoff_cosine)/self_shadow_cutoff_cosine);
float clarity = clamp(fogShadingParameter
- fogShadingParameter * length(eyeVec) / fogDistance, 0.0, 1.0);
col = mix(skyBgColor, col, clarity);
- gl_FragColor = vec4(col.rgb, base.a);
+ col = vec4(col.rgb, base.a);
+
+ gl_FragColor = col;
}
uniform mat4 LightMVP; // world matrix
+uniform vec4 CameraPos;
varying vec4 tPos;
#ifdef COLORED_SHADOWS
varying vec3 varColor;
vec4 getPerspectiveFactor(in vec4 shadowPosition)
{
- float pDistance = length(shadowPosition.xy);
+ vec2 s = vec2(shadowPosition.x > CameraPos.x ? 1.0 : -1.0, shadowPosition.y > CameraPos.y ? 1.0 : -1.0);
+ vec2 l = s * (shadowPosition.xy - CameraPos.xy) / (1.0 - s * CameraPos.xy);
+ float pDistance = length(l);
float pFactor = pDistance * xyPerspectiveBias0 + xyPerspectiveBias1;
- shadowPosition.xyz *= vec3(vec2(1.0 / pFactor), zPerspectiveBias);
-
+ l /= pFactor;
+ shadowPosition.xy = CameraPos.xy * (1.0 - l) + s * l;
+ shadowPosition.z *= zPerspectiveBias;
return shadowPosition;
}
uniform mat4 LightMVP; // world matrix
+uniform vec4 CameraPos; // camera position
varying vec4 tPos;
uniform float xyPerspectiveBias0;
vec4 getPerspectiveFactor(in vec4 shadowPosition)
{
- float pDistance = length(shadowPosition.xy);
+ vec2 s = vec2(shadowPosition.x > CameraPos.x ? 1.0 : -1.0, shadowPosition.y > CameraPos.y ? 1.0 : -1.0);
+ vec2 l = s * (shadowPosition.xy - CameraPos.xy) / (1.0 - s * CameraPos.xy);
+ float pDistance = length(l);
float pFactor = pDistance * xyPerspectiveBias0 + xyPerspectiveBias1;
- shadowPosition.xyz *= vec3(vec2(1.0 / pFactor), zPerspectiveBias);
-
+ l /= pFactor;
+ shadowPosition.xy = CameraPos.xy * (1.0 - l) + s * l;
+ shadowPosition.z *= zPerspectiveBias;
return shadowPosition;
}
/*
Custom update draw list for the pov of shadow light.
*/
-void ClientMap::updateDrawListShadow(const v3f &shadow_light_pos, const v3f &shadow_light_dir, float shadow_range)
+void ClientMap::updateDrawListShadow(v3f shadow_light_pos, v3f shadow_light_dir, float radius, float length)
{
ScopeProfiler sp(g_profiler, "CM::updateDrawListShadow()", SPT_AVG);
- const v3f camera_position = shadow_light_pos;
- const v3f camera_direction = shadow_light_dir;
- // I "fake" fov just to avoid creating a new function to handle orthographic
- // projection.
- const f32 camera_fov = m_camera_fov * 1.9f;
-
- v3s16 cam_pos_nodes = floatToInt(camera_position, BS);
+ v3s16 cam_pos_nodes = floatToInt(shadow_light_pos, BS);
v3s16 p_blocks_min;
v3s16 p_blocks_max;
- getBlocksInViewRange(cam_pos_nodes, &p_blocks_min, &p_blocks_max, shadow_range);
+ getBlocksInViewRange(cam_pos_nodes, &p_blocks_min, &p_blocks_max, radius + length);
std::vector<v2s16> blocks_in_range;
// they are not inside the light frustum and it creates glitches.
// FIXME: This could be removed if we figure out why they are missing
// from the light frustum.
- for (auto &i : m_drawlist) {
- i.second->refGrab();
- m_drawlist_shadow[i.first] = i.second;
- }
+ // for (auto &i : m_drawlist) {
+ // i.second->refGrab();
+ // m_drawlist_shadow[i.first] = i.second;
+ // }
// Number of blocks currently loaded by the client
u32 blocks_loaded = 0;
continue;
}
- float range = shadow_range;
-
- float d = 0.0;
- if (!isBlockInSight(block->getPos(), camera_position,
- camera_direction, camera_fov, range, &d))
+ v3f block_pos = intToFloat(block->getPos() * MAP_BLOCKSIZE, BS);
+ v3f projection = shadow_light_pos + shadow_light_dir * shadow_light_dir.dotProduct(block_pos - shadow_light_pos);
+ if (projection.getDistanceFrom(block_pos) > radius)
continue;
blocks_in_range_with_mesh++;
- /*
- Occlusion culling
- */
- if (isBlockOccluded(block, cam_pos_nodes)) {
- blocks_occlusion_culled++;
- continue;
- }
-
// This block is in range. Reset usage timer.
block->resetUsageTimer();
void getBlocksInViewRange(v3s16 cam_pos_nodes,
v3s16 *p_blocks_min, v3s16 *p_blocks_max, float range=-1.0f);
void updateDrawList();
- void updateDrawListShadow(const v3f &shadow_light_pos, const v3f &shadow_light_dir, float shadow_range);
+ void updateDrawListShadow(v3f shadow_light_pos, v3f shadow_light_dir, float radius, float length);
// Returns true if draw list needs updating before drawing the next frame.
bool needsUpdateDrawList() { return m_needs_update_drawlist; }
void renderMap(video::IVideoDriver* driver, s32 pass);
CachedPixelShaderSetting<f32> m_shadow_strength;
CachedPixelShaderSetting<f32> m_time_of_day;
CachedPixelShaderSetting<f32> m_shadowfar;
+ CachedPixelShaderSetting<f32, 4> m_camera_pos;
CachedPixelShaderSetting<s32> m_shadow_texture;
CachedVertexShaderSetting<f32> m_perspective_bias0_vertex;
CachedPixelShaderSetting<f32> m_perspective_bias0_pixel;
, m_shadow_strength("f_shadow_strength")
, m_time_of_day("f_timeofday")
, m_shadowfar("f_shadowfar")
+ , m_camera_pos("CameraPos")
, m_shadow_texture("ShadowMapSampler")
, m_perspective_bias0_vertex("xyPerspectiveBias0")
, m_perspective_bias0_pixel("xyPerspectiveBias0")
f32 shadowFar = shadow->getMaxShadowFar();
m_shadowfar.set(&shadowFar, services);
+ f32 cam_pos[4];
+ shadowViewProj.transformVect(cam_pos, light.getPlayerPos());
+ m_camera_pos.set(cam_pos, services);
+
// I dont like using this hardcoded value. maybe something like
// MAX_TEXTURE - 1 or somthing like that??
s32 TextureLayerID = 3;
void DirectionalLight::createSplitMatrices(const Camera *cam)
{
- float radius;
v3f newCenter;
v3f look = cam->getDirection();
float sfFar = adjustDist(future_frustum.zFar, cam->getFovY());
// adjusted camera positions
- v3f camPos2 = cam->getPosition();
- v3f camPos = v3f(camPos2.X - cam->getOffset().X * BS,
- camPos2.Y - cam->getOffset().Y * BS,
- camPos2.Z - cam->getOffset().Z * BS);
- camPos += look * sfNear;
- camPos2 += look * sfNear;
+ v3f cam_pos_world = cam->getPosition();
+ v3f cam_pos_scene = v3f(cam_pos_world.X - cam->getOffset().X * BS,
+ cam_pos_world.Y - cam->getOffset().Y * BS,
+ cam_pos_world.Z - cam->getOffset().Z * BS);
+ cam_pos_scene += look * sfNear;
+ cam_pos_world += look * sfNear;
// center point of light frustum
- float end = sfNear + sfFar;
- newCenter = camPos + look * (sfNear + 0.05f * end);
- v3f world_center = camPos2 + look * (sfNear + 0.05f * end);
+ v3f center_scene = cam_pos_scene + look * 0.35 * (sfFar - sfNear);
+ v3f center_world = cam_pos_world + look * 0.35 * (sfFar - sfNear);
// Create a vector to the frustum far corner
const v3f &viewUp = cam->getCameraNode()->getUpVector();
v3f farCorner = (look + viewRight * tanFovX + viewUp * tanFovY).normalize();
// Compute the frustumBoundingSphere radius
- v3f boundVec = (camPos + farCorner * sfFar) - newCenter;
- radius = boundVec.getLength();
- // boundVec.getLength();
- float vvolume = radius;
- v3f frustumCenter = newCenter;
- v3f eye_displacement = direction * vvolume;
+ v3f boundVec = (cam_pos_scene + farCorner * sfFar) - center_scene;
+ float radius = boundVec.getLength();
+ float length = radius * 3.0f;
+ v3f eye_displacement = direction * length;
// we must compute the viewmat with the position - the camera offset
// but the future_frustum position must be the actual world position
- v3f eye = frustumCenter - eye_displacement;
- future_frustum.position = world_center - eye_displacement;
- future_frustum.length = vvolume;
- future_frustum.ViewMat.buildCameraLookAtMatrixLH(eye, frustumCenter, v3f(0.0f, 1.0f, 0.0f));
- future_frustum.ProjOrthMat.buildProjectionMatrixOrthoLH(future_frustum.length,
- future_frustum.length, -future_frustum.length,
- future_frustum.length,false);
+ v3f eye = center_scene - eye_displacement;
+ future_frustum.player = cam_pos_scene;
+ future_frustum.position = center_world - eye_displacement;
+ future_frustum.length = length;
+ future_frustum.radius = radius;
+ future_frustum.ViewMat.buildCameraLookAtMatrixLH(eye, center_scene, v3f(0.0f, 1.0f, 0.0f));
+ future_frustum.ProjOrthMat.buildProjectionMatrixOrthoLH(radius, radius,
+ 0.0f, length, false);
future_frustum.camera_offset = cam->getOffset();
}
float zNear = cam->getCameraNode()->getNearValue();
float zFar = getMaxFarValue();
if (!client->getEnv().getClientMap().getControl().range_all)
- zFar = MYMIN(zFar, client->getEnv().getClientMap().getControl().wanted_range * BS * 1.5);
+ zFar = MYMIN(zFar, client->getEnv().getClientMap().getControl().wanted_range * BS);
///////////////////////////////////
// update splits near and fars
createSplitMatrices(cam);
// get the draw list for shadows
client->getEnv().getClientMap().updateDrawListShadow(
- getPosition(), getDirection(), future_frustum.length);
+ getPosition(), getDirection(), future_frustum.radius, future_frustum.length);
should_update_map_shadow = true;
dirty = true;
v3f rotated_offset;
shadow_frustum.ViewMat.rotateVect(rotated_offset, intToFloat(cam_offset - shadow_frustum.camera_offset, BS));
shadow_frustum.ViewMat.setTranslation(shadow_frustum.ViewMat.getTranslation() + rotated_offset);
+ shadow_frustum.player += intToFloat(shadow_frustum.camera_offset - cam->getOffset(), BS);
shadow_frustum.camera_offset = cam_offset;
}
}
return shadow_frustum.position;
}
+v3f DirectionalLight::getPlayerPos() const
+{
+ return shadow_frustum.player;
+}
+
+v3f DirectionalLight::getFuturePlayerPos() const
+{
+ return future_frustum.player;
+}
+
const m4f &DirectionalLight::getViewMatrix() const
{
return shadow_frustum.ViewMat;
struct shadowFrustum
{
- float zNear{0.0f};
- float zFar{0.0f};
- float length{0.0f};
+ f32 zNear{0.0f};
+ f32 zFar{0.0f};
+ f32 length{0.0f};
+ f32 radius{0.0f};
core::matrix4 ProjOrthMat;
core::matrix4 ViewMat;
v3f position;
+ v3f player;
v3s16 camera_offset;
};
return direction;
};
v3f getPosition() const;
+ v3f getPlayerPos() const;
+ v3f getFuturePlayerPos() const;
/// Gets the light's matrices.
const core::matrix4 &getViewMatrix() const;
disable();
}
-
void ShadowRenderer::addNodeToShadowList(
scene::ISceneNode *node, E_SHADOW_MODE shadowMode)
{
cb->MaxFar = (f32)m_shadow_map_max_distance * BS;
cb->PerspectiveBiasXY = getPerspectiveBiasXY();
cb->PerspectiveBiasZ = getPerspectiveBiasZ();
+ cb->CameraPos = light.getFuturePlayerPos();
}
-
+
// set the Render Target
// right now we can only render in usual RTT, not
// Depth texture is available in irrlicth maybe we
if (!m_shadow_node_array.empty() && !m_light_list.empty()) {
for (DirectionalLight &light : m_light_list) {
- // Static shader values.
- m_shadow_depth_cb->MapRes = (f32)m_shadow_map_texture_size;
- m_shadow_depth_cb->MaxFar = (f32)m_shadow_map_max_distance * BS;
+ // Static shader values for entities are set in updateSMTextures
+ // SM texture for entities is not updated incrementally and
+ // must by updated using current player position.
+ m_shadow_depth_entity_cb->CameraPos = light.getPlayerPos();
// render shadows for the n0n-map objects.
m_driver->setRenderTarget(shadowMapTextureDynamicObjects, true,
core::matrix4 lightMVP = driver->getTransform(video::ETS_PROJECTION);
lightMVP *= driver->getTransform(video::ETS_VIEW);
+
+ f32 cam_pos[4];
+ lightMVP.transformVect(cam_pos, CameraPos);
+
lightMVP *= driver->getTransform(video::ETS_WORLD);
m_light_mvp_setting.set(lightMVP.pointer(), services);
m_perspective_bias1.set(&bias1, services);
f32 zbias = PerspectiveBiasZ;
m_perspective_zbias.set(&zbias, services);
+
+ m_cam_pos_setting.set(cam_pos, services);
}
m_color_map_sampler_setting("ColorMapSampler"),
m_perspective_bias0("xyPerspectiveBias0"),
m_perspective_bias1("xyPerspectiveBias1"),
- m_perspective_zbias("zPerspectiveBias")
+ m_perspective_zbias("zPerspectiveBias"),
+ m_cam_pos_setting("CameraPos")
{}
void OnSetMaterial(const video::SMaterial &material) override {}
f32 MaxFar{2048.0f}, MapRes{1024.0f};
f32 PerspectiveBiasXY {0.9f}, PerspectiveBiasZ {0.5f};
+ v3f CameraPos;
private:
CachedVertexShaderSetting<f32, 16> m_light_mvp_setting;
CachedVertexShaderSetting<f32> m_perspective_bias0;
CachedVertexShaderSetting<f32> m_perspective_bias1;
CachedVertexShaderSetting<f32> m_perspective_zbias;
+ CachedVertexShaderSetting<f32, 4> m_cam_pos_setting;
};
projects / minetest.git / commitdiff