SDL_RenderCopyExF does not have subpixel precision when SDL_RendererFlip argument is anything but SDL_FLIP_NONE

[TheRealNoobytube]

In SDL2, when using the SDL_RenderCopyExF function to render a texture to the screen, if the SDL_RendererFlip argument is anything other than SDL_FLIP_NONE e.g passed in SDL_FLIP_HORIZONTAL, the function loses its subpixel precision and renders the textures position in the window rounded to the nearest pixel.
Here is the code where the function is used:

void Texture::draw(float posX, float posY, float scaleX, float scaleY, int width, int height, int startX, int startY, int sizeX, int sizeY, SDL_RendererFlip flip) {
	SDL_FRect dstRect;

	dstRect.x = posX;
	dstRect.y = posY;

	std::cout << dstRect.x << "\n";

	//if width is less than 0, use the retrieved width values from SDL_QueryTexture. otherwise use the passed in width values
	dstRect.w = (width <= 0) ? dimensions.x * scaleX : width * scaleX;
	//if height is less than 0, use the retrieved height values from SDL_QueryTexture. otherwise use the passed in height values
	dstRect.h = (height <= 0) ? dimensions.y * scaleY : height * scaleY;

	SDL_Rect srcRect;
	srcRect.x = (startX < 0) ? 0 : startX;
	srcRect.y = (startY < 0) ? 0 : startY;
	srcRect.w = (sizeX < 0) ? dstRect.w / scaleX : sizeX;
	srcRect.h = (sizeY < 0) ? dstRect.h / scaleY : sizeY;

	

	SDL_RenderCopyExF(this->renderer, texture, &srcRect, &dstRect, 0, NULL, flip);
}

Here is an example of what this looks like. Notice how when the sprite moves to the left (which flips the sprite horizontally), that the movement is much more jittery and less precise:

[icculus]

This appears to be working in SDL3:

#define SDL_MAIN_USE_CALLBACKS 1  /* use the callbacks instead of main() */
#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>

/* We will use this renderer to draw into this window every frame. */
static SDL_Window *window = NULL;
static SDL_Renderer *renderer = NULL;
static SDL_Texture *texture = NULL;
static int direction = 0;
static SDL_FRect dest;

/* This function runs once at startup. */
SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
{
    if (!SDL_Init(SDL_INIT_VIDEO)) {
        SDL_Log("Couldn't initialize SDL: %s", SDL_GetError());
        return SDL_APP_FAILURE;
    }

    if (!SDL_CreateWindowAndRenderer("Hello SDL", 640, 480, 0, &window, &renderer)) {
        SDL_Log("Couldn't create window/renderer: %s", SDL_GetError());
        return SDL_APP_FAILURE;
    }

    SDL_SetRenderVSync(renderer, 1);

    SDL_Surface *surface = SDL_LoadBMP("physaudiodev.bmp");
    texture = SDL_CreateTextureFromSurface(renderer, surface);
    dest.x = (640 - surface->w) / 2;
    dest.y = (480 - surface->h) / 2;
    dest.w = surface->w;
    dest.h = surface->h;

    SDL_DestroySurface(surface);

    return SDL_APP_CONTINUE;  /* carry on with the program! */
}

/* This function runs when a new event (mouse input, keypresses, etc) occurs. */
SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event)
{
    if (event->type == SDL_EVENT_QUIT) {
        return SDL_APP_SUCCESS;  /* end the program, reporting success to the OS. */
    } else if (event->type == SDL_EVENT_KEY_DOWN) {
        if (event->key.repeat) {
            return SDL_APP_CONTINUE;
        } else if (event->key.key == SDLK_LEFT) {
            direction--;
        } else if (event->key.key == SDLK_RIGHT) {
            direction++;
        }
    } else if (event->type == SDL_EVENT_KEY_UP) {
        if (event->key.repeat) {
            return SDL_APP_CONTINUE;
        } else if (event->key.key == SDLK_LEFT) {
            direction++;
        } else if (event->key.key == SDLK_RIGHT) {
            direction--;
        }
    }
    return SDL_APP_CONTINUE;  /* carry on with the program! */
}

/* This function runs once per frame, and is the heart of the program. */
SDL_AppResult SDL_AppIterate(void *appstate)
{
    dest.x += (0.3f * ((float)direction));
    SDL_SetRenderDrawColor(renderer, 33, 33, 33, 255);
    SDL_RenderClear(renderer);
    SDL_RenderTextureRotated(renderer, texture, NULL, &dest, 0, NULL, (direction < 0) ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE);
    SDL_RenderPresent(renderer);
    return SDL_APP_CONTINUE;  /* carry on with the program! */
}

/* This function runs once at shutdown. */
void SDL_AppQuit(void *appstate, SDL_AppResult result)
{
    SDL_DestroyTexture(texture);
    /* SDL will clean up the window/renderer for us. */
}

...so I'm going to move this back to an SDL2 milestone.