Will SDL_Renderer ever support vertex shader uniforms or programmable vertex shading?

[Umbre373]

In SDL 3, SDL_SetRenderGPUState allows fragment shaders and GPU state to be set via the SDL_Renderer API, enabling customization without dropping to the low-level GPU API.

However, there’s no equivalent support for vertex shaders — no way to provide custom vertex code or set uniforms like model/view/projection matrices. This makes it difficult to implement camera systems or geometry transforms cleanly.

Currently, the only options are:
• Use the SDL_GPU* API, which is powerful but much more complex;
• Apply all transformations on the CPU, which is less elegant and less flexible.

A simple solution could be to add an optional 3×2 or 4×4 matrix parameter to SDL_RenderGeometryRaw, applied on the GPU before rasterization. This would cover most 2D use cases without requiring full vertex shader support.

Is such an addition planned? Or is vertex shader support via SDL_Renderer something that could be considered?

[slouken]

There are currently no plans to add vertex shaders to the render API. Setting an additional transformation matrix is something that we could potentially do, but we'd have to revisit implementing mipmaps in #10254. Feel free to submit a draft PR if you whip something up that meets your needs.

[Umbre373]

I understand that full vertex shader support isn’t planned, and that’s perfectly reasonable. Even just having a rendering function that accepts a transformation matrix along with vertex data would already be a huge improvement.

It would cover common use cases like camera systems, scrolling, and zoom — without needing to manually transform all vertices on the CPU, which quickly becomes inefficient and error-prone, even in relatively simple 2D games with large maps or procedurally generated content. Libraries like SFML and raylib support similar functionality with great results.

Unfortunately, I don’t have enough GPU programming experience to implement this myself — otherwise I’d be happy to submit a PR. Thanks again for considering the idea!

[slouken]

Can you put together a demo that manually transforms the vertices to achieve the effect you want, so I can see how it would work?

[Umbre373]

Here’s a working CPU-side demo:

https://gist.github.com/Umbre373/50b0e3df07a464f81eb69c6cec8761af

Here’s a working CPU-side demo that manually transforms all vertices using a 3×3 affine matrix to simulate camera movement, zoom, and rotation. It renders a 1000×1000 grid of sprites (6 million vertices) using SDL_RenderGeometryRaw.

You can move the view with the arrow keys, zoom in/out with W/S, and rotate with Q/E.

This example demonstrates the kind of transformation that would ideally be handled on the GPU via a transformation matrix passed to the rendering function. Doing it on the CPU works, but it’s not efficient or elegant — especially for large procedural maps or high-density scenes.

Let me know if this helps clarify the use case!

[slouken]

Thanks for the example! That's helpful for thinking about this.

[expikr]

Marginally Related: #11276

#12659 could be expanded to take transform parameter(s) as argument