Implementing batching in the renderer

[Lazin3ss]

Right now, the renderer performs a draw call for each individual texture and geometry that must be drawn in the screen. This results in a lot of inefficient context change, GPU calling and CGO calls that impair frame rate in different computers, something that can be observed in things like text rendering or in-game particles (made by lots of explods). My proposal is to rewrite/refactor code where necessary as to minimize instances of data transfering from the CPU to the GPU by sending it in batches, and thus achieving greater frame rates.

@samhocevar suggested some changes to be made in order to make this possible (citing from him):

• Reduce the number of textures used by the font (could use an atlas packing library such as https://pkg.go.dev/github.com/cozely/cozely/x/atlas)
• Patch or fork the glfont library so that it does the same
• Find a way to handle glfont’s dynamic glyph allocation
• Ensure Ikemen sprites carry UV coordinates in addition to just the texture object
• Refactor the rendering code in src/render.go so that filling the render buffer can be done separately from the actual draw call
• Perform tiling on the GPU

[assemblaj]

Welp, it's not in the nightly yet, but I"ve implemented batching (and other optimizations) in IKEMEN. :-)

Big thanks to @samhocevar , I know you've moved on but this wouldn't be possible without the groundwork you laid with your rendering layer.

My optimizations include:

• Caching palettes using xxhash (you're going to see this term a lot) to prevent new textures being created on the fly, which was causing a lot of glTexImage2D calls during the render loop
• Using multiple vertex buffers and alternating between them for a double buffering scheme
• Caching the state of the vertex buffer itself for UI using xxHash since it's mostly static and where the bulk of our glBufferData (a big performance hinderance) calls were coming from
• Batching, this was done by making helper functions that are similar to RenderSprite and FillRect that collect the uniforms and some render params that would be sent to the GPU via the renderWithBlending function instead of rendering. I then iterate over those uniforms at the end of rendering and if I find consecutive ones that match (based on hashing the uniforms using xxhash), I batch render them.
• Using a texture atlas for TTF and Sprite fonts as well as Lifebar and some fightfx

For the font library, the first thing I initially did was just collect all of the vertices for a single Printf call and glBufferSubData'd them all at once, which gave great results despite not being proper batch rendering. Now I use batch rendering there with the texture atlas. I can actually print a whole screen of text all at once with one render call:

2024-04-08.04-18-44.online-video-cutter.com.mp4

There's also a lot of optimizations with regards to the objects created by the batching scheme to make sure they do not impact the garbage collector.

And there's still more things that can be done. When I figure out what it means to 'perform tiling on the GPU' we'll really be in business :)

IKEMEN Batching 3.5 Source
Ikemen_GO-batch_v3.5.zip