1 files changed, 53 insertions, 27 deletions

diff --git a/src/client/shadows/dynamicshadows.cpp b/src/client/shadows/dynamicshadows.cpp
index 6ef5a4f1d..9f26ba94a 100644
--- a/src/client/shadows/dynamicshadows.cpp
+++ b/src/client/shadows/dynamicshadows.cpp
@@ -27,11 +27,24 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 using m4f = core::matrix4;
 
+static v3f quantizeDirection(v3f direction, float step)
+{
+
+	float yaw = std::atan2(direction.Z, direction.X);
+	float pitch = std::asin(direction.Y); // assume look is normalized
+
+	yaw = std::floor(yaw / step) * step;
+	pitch = std::floor(pitch / step) * step;
+
+	return v3f(std::cos(yaw)*std::cos(pitch), std::sin(pitch), std::sin(yaw)*std::cos(pitch));
+}
+
 void DirectionalLight::createSplitMatrices(const Camera *cam)
 {
-	float radius;
+	const float DISTANCE_STEP = BS * 2.0; // 2 meters
 	v3f newCenter;
 	v3f look = cam->getDirection();
+	look = quantizeDirection(look, M_PI / 12.0); // 15 degrees
 
 	// camera view tangents
 	float tanFovY = tanf(cam->getFovY() * 0.5f);
@@ -42,42 +55,42 @@ void DirectionalLight::createSplitMatrices(const Camera *cam)
 	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();
+	cam_pos_world = v3f(
+			floor(cam_pos_world.X / DISTANCE_STEP) * DISTANCE_STEP,
+			floor(cam_pos_world.Y / DISTANCE_STEP) * DISTANCE_STEP,
+			floor(cam_pos_world.Z / DISTANCE_STEP) * DISTANCE_STEP);
+	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 viewRight = look.crossProduct(viewUp);
 
-	v3f farCorner = look + viewRight * tanFovX + viewUp * tanFovY;
+	v3f farCorner = (look + viewRight * tanFovX + viewUp * tanFovY).normalize();
 	// Compute the frustumBoundingSphere radius
-	v3f boundVec = (camPos + farCorner * sfFar) - newCenter;
-	radius = boundVec.getLength() * 2.0f;
-	// boundVec.getLength();
-	float vvolume = radius * 2.0f;
-
-	v3f frustumCenter = newCenter;
-	// probar radius multipliacdor en funcion del I, a menor I mas multiplicador
-	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 = quantizeDirection(direction, M_PI / 2880 /*15 seconds*/) * 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();
 }
 
@@ -95,6 +108,8 @@ void DirectionalLight::update_frustum(const Camera *cam, Client *client, bool fo
 
 	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);
 
 	///////////////////////////////////
 	// update splits near and fars
@@ -105,7 +120,7 @@ void DirectionalLight::update_frustum(const Camera *cam, Client *client, bool fo
 	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;
 
@@ -115,6 +130,7 @@ void DirectionalLight::update_frustum(const Camera *cam, Client *client, bool fo
 		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;
 	}
 }
@@ -139,6 +155,16 @@ v3f DirectionalLight::getPosition() const
 	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;