In SDL2 what is the fastest / most efficient way to draw pixels onto the screen? Using SDL_RenderDrawPoint or SDL_RenderCopy with a Texture?

Question

I want to add pixel splatters and particle effects to a game. For this my options were to have a bunch of pre-made animations in the form of textures, OR create a particle engine.

For the particle engine approach, my options as far as I know are to create pixels and render them either using:

1. SDL_RenderDrawPoint(s) (Using SDL_SetRenderDrawColor)
2. SDL_RenderCopy (Using Textures with SDL_SetTextureColorMod)

I'm not sure what's a better approach. #2 is probably easier as I have a whole system built around fast texture rendering (not necessarily faster than 1., but seemingly easier to implement with my current system.) #1 seems ideal because it's in the SDL2 library for a reason I'd think, but really I'm unsure which approach I should go with.

Answer 1

So I ran both Functions 100,000 times (ran it a few times just to make sure), and timed it using time.h . I rendered a simple 1x1 pixel at 0,0 and a texture of a 1x1 pixel at 0,0. Below is basically a single trial I found.

SDL_RenderDrawPoint: Time taken 9 milliseconds

SDL_RenderCopy: Time taken 266 milliseconds

Not surprisingly the RenderDrawPoint is much faster than RenderCopy. My trial wasn't super perfect as I might have been able to use a more optimized Texture, and had to use some variables with values for SDL_RenderCopy, but I doubt it added much time to make RenderCopy come even close to RenderDrawPoint.

Edit (Here's essentially the code I used, renderer is the window renderer, texture is a 1x1 bitmap surface in a texture loaded using RLE optimization):

#include <time.h>
#include <SDL2/SDL.h>

SDL_Rect clip;
clip.x = 0;
clip.y = 0;
clip.w = 1;
clip.h = 1;

int msec, i;
clock_t start, diff;

i = 100000;
start = clock()
while(i-- > 0)
{
    SDL_RenderDrawPoint(renderer, 0, 0);
}
diff = clock() - start;

msec = diff * 1000 / CLOCKS_PER_SEC;
fprintf(stdout, "Time taken %d seconds %d milliseconds", msec/1000, msec%1000);

i = 100000;
start = clock()
while(i-- > 0)
{
    SDL_RenderCopy(renderer, texture, &clip, &clip);
}
diff = clock() - start;

msec = diff * 1000 / CLOCKS_PER_SEC;
fprintf(stdout, "Time taken %d seconds %d milliseconds", msec/1000, msec%1000);

Answer 2

Neither of those: use SDL_LockSurface to directly access directly the surface data. Then changing pixels is changing values in an array, which is fastest.