Fix and improve view range tuner

src/camera.cpp

@@ -33,6 +33,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "gamedef.h"
 #include "sound.h"
 #include "event.h"
+#include "profiler.h"
 #include "util/numeric.h"
 #include "util/mathconstants.h"
 
@@ -57,10 +58,10 @@ Camera::Camera(scene::ISceneManager* smgr, MapDrawControl& draw_control,
 	m_fov_x(1.0),
 	m_fov_y(1.0),
 
-	m_added_frametime(0),
+	m_added_busytime(0),
 	m_added_frames(0),
 	m_range_old(0),
-	m_frametime_old(0),
+	m_busytime_old(0),
 	m_frametime_counter(0),
 	m_time_per_range(30. / 50), // a sane default of 30ms per 50 nodes of range
 
@@ -242,8 +243,8 @@ void Camera::step(f32 dtime)
 	}
 }
 
-void Camera::update(LocalPlayer* player, f32 frametime, v2u32 screensize,
+void Camera::update(LocalPlayer* player, f32 frametime, f32 busytime,
-		f32 tool_reload_ratio)
+		v2u32 screensize, f32 tool_reload_ratio)
 {
 	// Get player position
 	// Smooth the movement when walking up stairs
@@ -416,7 +417,7 @@ void Camera::update(LocalPlayer* player, f32 frametime, v2u32 screensize,
 	m_wieldlight = player->light;
 
 	// Render distance feedback loop
-	updateViewingRange(frametime);
+	updateViewingRange(frametime, busytime);
 
 	// If the player seems to be walking on solid ground,
 	// view bobbing is enabled and free_move is off,
@@ -440,23 +441,22 @@ void Camera::update(LocalPlayer* player, f32 frametime, v2u32 screensize,
 	}
 }
 
-void Camera::updateViewingRange(f32 frametime_in)
+void Camera::updateViewingRange(f32 frametime_in, f32 busytime_in)
 {
 	if (m_draw_control.range_all)
 		return;
 
-	m_added_frametime += frametime_in;
+	m_added_busytime += busytime_in;
 	m_added_frames += 1;
 
-	// Actually this counter kind of sucks because frametime is busytime
 	m_frametime_counter -= frametime_in;
 	if (m_frametime_counter > 0)
 		return;
-	m_frametime_counter = 0.2;
+	m_frametime_counter = 0.2; // Same as ClientMap::updateDrawList interval
 
 	/*dstream<<__FUNCTION_NAME
 			<<": Collected "<<m_added_frames<<" frames, total of "
-			<<m_added_frametime<<"s."<<std::endl;
+			<<m_added_busytime<<"s."<<std::endl;
 
 	dstream<<"m_draw_control.blocks_drawn="
 			<<m_draw_control.blocks_drawn
@@ -466,7 +466,7 @@ void Camera::updateViewingRange(f32 frametime_in)
 
 	// Get current viewing range and FPS settings
 	f32 viewing_range_min = g_settings->getS16("viewing_range_nodes_min");
-	viewing_range_min = MYMAX(5.0, viewing_range_min);
+	viewing_range_min = MYMAX(15.0, viewing_range_min);
 
 	f32 viewing_range_max = g_settings->getS16("viewing_range_nodes_max");
 	viewing_range_max = MYMAX(viewing_range_min, viewing_range_max);
@@ -503,17 +503,17 @@ void Camera::updateViewingRange(f32 frametime_in)
 
 	// Calculate the average frametime in the case that all wanted
 	// blocks had been drawn
-	f32 frametime = m_added_frametime / m_added_frames / block_draw_ratio;
+	f32 frametime = m_added_busytime / m_added_frames / block_draw_ratio;
 
-	m_added_frametime = 0.0;
+	m_added_busytime = 0.0;
 	m_added_frames = 0;
 
 	f32 wanted_frametime_change = wanted_frametime - frametime;
 	//dstream<<"wanted_frametime_change="<<wanted_frametime_change<<std::endl;
+	g_profiler->avg("wanted_frametime_change", wanted_frametime_change);
 
 	// If needed frametime change is small, just return
 	// This value was 0.4 for many months until 2011-10-18 by c55;
-	// Let's see how this works out.
 	if (fabs(wanted_frametime_change) < wanted_frametime*0.33)
 	{
 		//dstream<<"ignoring small wanted_frametime_change"<<std::endl;
@@ -524,22 +524,24 @@ void Camera::updateViewingRange(f32 frametime_in)
 	f32 new_range = range;
 
 	f32 d_range = range - m_range_old;
-	f32 d_frametime = frametime - m_frametime_old;
+	f32 d_busytime = busytime_in - m_busytime_old;
 	if (d_range != 0)
 	{
-		m_time_per_range = d_frametime / d_range;
+		m_time_per_range = d_busytime / d_range;
 	}
+	//dstream<<"time_per_range="<<m_time_per_range<<std::endl;
+	g_profiler->avg("time_per_range", m_time_per_range);
 
 	// The minimum allowed calculated frametime-range derivative:
 	// Practically this sets the maximum speed of changing the range.
 	// The lower this value, the higher the maximum changing speed.
 	// A low value here results in wobbly range (0.001)
+	// A low value can cause oscillation in very nonlinear time/range curves.
 	// A high value here results in slow changing range (0.0025)
 	// SUGG: This could be dynamically adjusted so that when
 	//       the camera is turning, this is lower
-	//f32 min_time_per_range = 0.0015;
+	//f32 min_time_per_range = 0.0010; // Up to 0.4.7
-	f32 min_time_per_range = 0.0010;
+	f32 min_time_per_range = 0.0005;
-	//f32 min_time_per_range = 0.05 / range;
 	if(m_time_per_range < min_time_per_range)
 	{
 		m_time_per_range = min_time_per_range;
@@ -572,10 +574,10 @@ void Camera::updateViewingRange(f32 frametime_in)
 	/*dstream<<"new_range="<<new_range_unclamped
 			<<", clamped to "<<new_range<<std::endl;*/
 
-	m_draw_control.wanted_range = new_range;
+	m_range_old = m_draw_control.wanted_range;
+	m_busytime_old = busytime_in;
 
-	m_range_old = new_range;
+	m_draw_control.wanted_range = new_range;
-	m_frametime_old = frametime;
 }
 
 void Camera::setDigging(s32 button)

src/camera.h

@@ -105,12 +105,12 @@ public:
 	void step(f32 dtime);
 
 	// Update the camera from the local player's position.
-	// frametime is used to adjust the viewing range.
+	// busytime is used to adjust the viewing range.
-	void update(LocalPlayer* player, f32 frametime, v2u32 screensize,
+	void update(LocalPlayer* player, f32 frametime, f32 busytime,
-			f32 tool_reload_ratio);
+			v2u32 screensize, f32 tool_reload_ratio);
 
 	// Render distance feedback loop
-	void updateViewingRange(f32 frametime_in);
+	void updateViewingRange(f32 frametime_in, f32 busytime_in);
 
 	// Start digging animation
 	// Pass 0 for left click, 1 for right click
@@ -151,10 +151,10 @@ private:
 	f32 m_fov_y;
 
 	// Stuff for viewing range calculations
-	f32 m_added_frametime;
+	f32 m_added_busytime;
 	s16 m_added_frames;
 	f32 m_range_old;
-	f32 m_frametime_old;
+	f32 m_busytime_old;
 	f32 m_frametime_counter;
 	f32 m_time_per_range;
 

src/clientmap.cpp

@@ -215,6 +215,8 @@ void ClientMap::updateDrawList(video::IVideoDriver* driver)
 	//u32 blocks_had_pass_meshbuf = 0;
 	// Blocks from which stuff was actually drawn
 	//u32 blocks_without_stuff = 0;
+	// Distance to farthest drawn block
+	float farthest_drawn = 0;
 
 	for(std::map<v2s16, MapSector*>::iterator
 			si = m_sectors.begin();
@@ -347,6 +349,8 @@ void ClientMap::updateDrawList(video::IVideoDriver* driver)
 
 			sector_blocks_drawn++;
 			blocks_drawn++;
+			if(d/BS > farthest_drawn)
+				farthest_drawn = d/BS;
 
 		} // foreach sectorblocks
 
@@ -356,6 +360,7 @@ void ClientMap::updateDrawList(video::IVideoDriver* driver)
 
 	m_control.blocks_would_have_drawn = blocks_would_have_drawn;
 	m_control.blocks_drawn = blocks_drawn;
+	m_control.farthest_drawn = farthest_drawn;
 
 	g_profiler->avg("CM: blocks in range", blocks_in_range);
 	g_profiler->avg("CM: blocks occlusion culled", blocks_occlusion_culled);
@@ -363,6 +368,7 @@ void ClientMap::updateDrawList(video::IVideoDriver* driver)
 		g_profiler->avg("CM: blocks in range without mesh (frac)",
 				(float)blocks_in_range_without_mesh/blocks_in_range);
 	g_profiler->avg("CM: blocks drawn", blocks_drawn);
+	g_profiler->avg("CM: farthest drawn", farthest_drawn);
 	g_profiler->avg("CM: wanted max blocks", m_control.wanted_max_blocks);
 }
 

src/clientmap.h

@@ -33,7 +33,8 @@ struct MapDrawControl
 		wanted_max_blocks(0),
 		wanted_min_range(0),
 		blocks_drawn(0),
-		blocks_would_have_drawn(0)
+		blocks_would_have_drawn(0),
+		farthest_drawn(0)
 	{
 	}
 	// Overrides limits by drawing everything
@@ -48,6 +49,8 @@ struct MapDrawControl
 	u32 blocks_drawn;
 	// Number of blocks that would have been drawn in wanted_range
 	u32 blocks_would_have_drawn;
+	// Distance to the farthest block drawn
+	float farthest_drawn;
 };
 
 class Client;

src/game.cpp

@@ -2456,7 +2456,8 @@ void the_game(
 		float full_punch_interval = playeritem_toolcap.full_punch_interval;
 		float tool_reload_ratio = time_from_last_punch / full_punch_interval;
 		tool_reload_ratio = MYMIN(tool_reload_ratio, 1.0);
-		camera.update(player, busytime, screensize, tool_reload_ratio);
+		camera.update(player, dtime, busytime, screensize,
+				tool_reload_ratio);
 		camera.step(dtime);
 
 		v3f player_position = player->getPosition();
@@ -2875,6 +2876,7 @@ void the_game(
 		else
 		{
 			fog_range = draw_control.wanted_range*BS + 0.0*MAP_BLOCKSIZE*BS;
+			fog_range = MYMIN(fog_range, (draw_control.farthest_drawn+20)*BS);
 			fog_range *= 0.9;
 			if(draw_control.range_all)
 				fog_range = 100000*BS;