I am experiencing stutter when I am moving faster than 0.1 units in my program.

[![jittery motion on 0.3 units][1]][1]


When doing exactly 0.1 units I get:

[![smooth motion on 0.1][2]][2]
  [1]: https://i.sstatic.net/8Sd6y.gif
  [2]: https://i.sstatic.net/Wsh4v.gif

For test purposes I've made the bot always heading southeast.

    int main()
{
	
// Intialize SDL2
	
SDL_Init(SDL_INIT_EVERYTHING);

	// Defining world & window dimensions and camera position
	const int SCREEN_WIDTH{ 800 };
	const int SCREEN_HEIGHT{ 480 };
	const int WORLD_WIDTH{ 1000 };
	const int WORLD_HEIGHT{ 1000 };
	int view_x{ 0 };
	int view_y{ 0 };

	// Create window and default rendering context
	SdlCreateWindowAndRendererWrapped wr{ SCREEN_WIDTH, SCREEN_HEIGHT };
	SDL_Renderer * const ren{ &wr.get_resource_renderer() };

	Object ground(ren, "assets/ground.png", 0, 0, 95);
	ground.set_size(600);
	ground.set_pos(200, 200);

	Object bot(ren, "assets/bot.png", 40, 46, 32);
	bot.set_size(200);

	// Game loop
	bool is_running{ true };
	SDL_Event event{};
	SDL_SetRenderDrawColor(ren, 0, 0, 0, 0);
	while (is_running) {
		Uint64 start = SDL_GetPerformanceCounter();
		/*--------------Event loop--------------*/
		while (SDL_PollEvent(&event))
		{
			if (event.type == SDL_QUIT)
			{
				is_running = false;
			}
		} // end of the event loop

		/*--------------Physics loop--------------*/
		static Clock clock;
		clock.tick();
		Vec2f v{ 0.3f, 0.3f };
		bot.move(v, clock.delta);

		// Screen coordinate translations
		bot.set_pos(bot.get_pos().x - view_x, bot.get_pos().y - view_y);
		ground.set_pos(ground.get_pos().x - view_x, ground.get_pos().y - view_y);
		ground.update();
		bot.update();

		// Check camera bounds
		if (view_x < 0)
		{
			view_x = 0;
		}
		if (view_y < 0)
		{
			view_y = 0;
		}
		if (view_x > WORLD_WIDTH - SCREEN_WIDTH)
		{
			view_x = WORLD_WIDTH - SCREEN_WIDTH;
		}
		if (view_y > WORLD_HEIGHT - SCREEN_HEIGHT)
		{
			view_y = WORLD_HEIGHT - SCREEN_HEIGHT;
		}

		// Make the camera follow the bot
		view_x = bot.get_pos().x - SCREEN_WIDTH / 2;
		view_y = bot.get_pos().y - SCREEN_HEIGHT / 2;

		/*--------------Rendering loop--------------*/
		SDL_RenderClear(ren);
		ground.draw(ren);
		bot.draw(ren);
		SDL_RenderPresent(ren);

		/*--------------Todo: Animation loop--------------*/

		// Cap to 60 FPS (approx. 16.666 ms per frame -- the cycle time)
		Uint64 end = SDL_GetPerformanceCounter();
		float elapsed_ms{ (end - start) / static_cast<float>(SDL_GetPerformanceFrequency()) * 1000.0f };
		if (std::isless(elapsed_ms, 16.666f))
		{
			SDL_Delay(static_cast<int>(floorf(16.666f - elapsed_ms)));
		}
	}

	// Clean up used resources
	SDL_Quit();
	return 0;
}

I took inspiration for designing my game loop from

https://thenumbat.github.io/cpp-course/sdl2/08/08.html

The Clock class/struct was implemented exactly as Salajouni's one:

https://gamedev.stackexchange.com/questions/110825/how-to-calculate-delta-time-with-sdl

The camera was implemented via this method:

https://wiki.allegro.cc/index.php?title=How_to_implement_a_camera


This is how my Object struct/class looks like:

https://privatebin.net/?6207e549bccc31ea#+DM71i2b2YW+iVT6vLu5cG3x3tMol5uk57MT240WMOI=

The part that supposedly needs the most attention is the **physics loop**.
This is the part where all the motion and motion updates happen.
In there I define a velocity vector and set both of its components too 0.3.
After that the stutter/jitter happens. However, when I do 0.1, then it runs smoothly as shown in the pictures above.
I created the window via SDL_CreateWindowAndRenderer(). So accelerated rendering should be active. I am not sure whether or not VSYNC gets activated as well when doing SDL_CreateWindowAndRenderer().

So what could possibly be the cause? Is it due to cascading rounding errors?
Is it due to the active VSYNC and the manual framerate cap at the end of the loop? What is it exactly that is causing the stutter?

PS: And for possibility that my Vector2 template class needs attention as well, there you go:

https://privatebin.net/?a9a77f753086b6ea#6c7tuaYyU+aasAEtwBPt0o1k9Y1NaZkyZfFGDKV2arc=

It is just a simple templated 2D vector math class. Nothing scary.