SDL_ttf | font files with Simple Directmedia Layer | User Interface library

You recursively apply blend operation multiple times on the same data.

Your render texture have the same size as your window. You didn't clear it, so let's presume it is zeroed by default, including alpha (it may be implementation-dependant, i don't see documentation states that anywyere; explicit clear with required colour may be a good idea).

SDL_ttf gives you surface with alpha channel. Then you render your first text fragment to that texture with blendmode=blend, blending it atop of zeroes. If you look at the formulas for blend operations - alpha values of your render target gets overwritten by your text texture (dstA = srcA + (dstA * (1-srcA)), and dstA is 0, so it is just srcA), but colour values are multiplied by your source alpha, so srcRGB = srcRGB * srcA.

Then you blend this target texture on top of your screen, which is cleared to (0, 0, 0, 255), applying the same blend operation again, resulting in another blending by the same srcA, so your colours are now srcRGB = srcRGB * srcA * srcA. This is obviously incorrect.

It gets worse with your second text fragment, because you do all that again, but never clear your render target. So when you use your render target again, you do another rendering of entire texture, including what was rendered at first text fragment, applying another blend on top of that.

You need to do blending only once. There are multiple ways to do so, and you'll have to decide what's best for your case. I don't know how you want to use your render texture, so presuming you want to keep alpha values, you need to do blending at last stage. That can be achieved by drawing into render target with blendmode=none, and then blitting your render texture onto screen, but only once. For example:

You can use g++ to build your program in two ways:

• In two stages, first by compiling the individual .cpp files as translation units to object files .o and then in another invocation of g++ to link them together into an executable

• Or you can use a single invocation of g++ to compile and link the executable.

You are currently trying to mix the two modes somehow. For the single-invocation build you should call g++ only once and add all .cpp files to it:

Yes, I was missing something obvious : DLLs are specifically for Windows

Now, as for getting an executable to work without installing the required libraries, I still haven't managed that (linking statically didn't pan out, in my case), but at least I learnt something.

If I give cross-compilation to Windows a try, I'll try to update this.

It's because once you've outputed something to the screen, it stays there unless you clear it or put something above it.

Think of it as a painter plotting things on his canvas. If you want to overwrite something, you have to overwrite the previous shape.

The simplest way to deal with this would be to call SDL_RenderClear at the beginning of every draw, it clears the whole screen clean, and then every time you render something it'll never overlap the previous stuff.

You are setting your destination rectangle to be different than the text that was rendered to the surface so it will stretch.
You should also free up the surface before your main loop.
So the code I think you are looking for:

The issue may be that you're using SDL_MixAudio.

Your code mixes in the data from the .wav file, but mixes it into what?

What is in stream before calling SDL_MixAudio?

I get the same buzz, but when I use memset to zero out the stream buffer before calling SDL_MixAudio, I get the correct sound from the .wav file.

I don't know for sure but I believe that on the second and subsequent calls to your mixing function, the data from the prior callback is still in the stream buffer.

Side note: When the .wav data has finished playing, we can reset sound.dpos to replay the file again.

Here's the refactored code:

I found an Answer for myself. It seems like the Errors appear randomly. After relaunching Vscode 2-3 times, the errors appear or do not appear randomly. Seems like a problem with the IDE 😐

Would something like this be acceptable?

CMAKE_POSITION_INDEPENDENT_CODE only influences targets defined after it has been set. However, you're setting CMAKE_POSITION_INDEPENDENT_CODE to ON after including the extern subdirectory, which is why the external libraries are not built with position-independent code.