Performance?

[Jipok]

Can you do some performance tests? Something like in JupiterRider/purego-sdl3#4 (comment)

I am sure that the overhead is acceptable if we are talking about calls to create a window and handle input events. But what if these are thousands of calls to draw primitives every 8 milliseconds(120 Hz)? Will this not overload the CPU?
I wanted to make a really effective UI, although I do not mind losing a couple of percent of performance.

[Zyko0]

Yes, I can, I will try to port the code from JupiterRider, it shouldn't be too different than this sdl3 bindings implementation.
My guess is that the performance should be pretty close, since we're both using ebitengine/purego.

This implementation doesn't rely on purego.RegisterLibFunc (which creates a function via reflection that adds overhead at runtime) and instead tries to make the syscall directly via purego.SyscallN which has an overhead closer to CGo.

You're right in that calling many times a library function from Go via CGo or purego has an overhead.
I'll make the test when I have time!

What I would suggest for your case and in general, is to batch the geometry at the software level and try to minimize calls to SDL.
You can probably use sdl.RenderGeometry with many triangles at once for example (https://github.com/Zyko0/go-sdl3/blob/main/examples/renderer/10-geometry/main.go), instead of going for RenderTexture in a loop.

[Zyko0]

Below is the code adapted to these bindings.
The image "raybunny.png" is taken from Raylib

I'm not sure how to display the FPS the way JupiterRider did, neither how to compare

Code

package main

import (
	_ "embed"
	"fmt"
	"image/color"
	"math/rand"

	"github.com/Zyko0/go-sdl3/bin/binimg"
	"github.com/Zyko0/go-sdl3/bin/binsdl"
	"github.com/Zyko0/go-sdl3/img"
	sdl "github.com/Zyko0/go-sdl3/sdl"
)

const maxBunnies = 50_000
const width, height = 1280, 720

func main() {
	defer binsdl.Load().Unload()
	defer binimg.Load().Unload()

	defer sdl.Quit()
	if err := sdl.Init(sdl.INIT_VIDEO); err != nil {
		panic(err)
	}

	window, renderer, err := sdl.CreateWindowAndRenderer("Bunnymark", width, height, sdl.WINDOW_RESIZABLE)
	if err != nil {
		panic(err)
	}
	defer renderer.Destroy()
	defer window.Destroy()

	surface, err := img.Load("raybunny.png")
	if err != nil {
		panic(err)
	}

	texture, err := renderer.CreateTextureFromSurface(surface)
	if err != nil {
		panic(err)
	}
	defer texture.Destroy()
	surface.Destroy()

	var bunniesCount int = 0
	var bunnies [maxBunnies]Bunny

	last := sdl.TicksNS()

Outer:
	for {
		var event sdl.Event
		for sdl.PollEvent(&event) {
			switch event.Type {
			case sdl.EVENT_QUIT:
				break Outer
			case sdl.EVENT_KEY_DOWN:
				evt := event.KeyboardEvent()
				if evt.Scancode == sdl.SCANCODE_ESCAPE {
					break Outer
				}
			case sdl.EVENT_MOUSE_BUTTON_DOWN:
				evt := event.MouseButtonEvent()
				if btn := evt.Button; btn == uint8(sdl.BUTTON_LEFT) {
					for i := 0; i < 100; i++ {
						if bunniesCount < maxBunnies {
							bunnies[bunniesCount].PositionX = evt.X
							bunnies[bunniesCount].PositionY = evt.Y
							bunnies[bunniesCount].SpeedX = float32(rand.Intn(501) - 250)
							bunnies[bunniesCount].SpeedY = float32(rand.Intn(501) - 250)
							bunnies[bunniesCount].Color.R = byte(rand.Intn(240+1-50) + 50)
							bunnies[bunniesCount].Color.G = byte(rand.Intn(240+1-80) + 80)
							bunnies[bunniesCount].Color.B = byte(rand.Intn(240+1-100) + 100)
							bunniesCount++
						}
					}
				}
			}
		}

		renderer.SetDrawColor(255, 255, 255, 255)
		renderer.Clear()

		now := sdl.TicksNS()
		ticks := now - last
		last = now
		delta := float64(ticks) / 1_000_000_000.0

		for i := 0; i < bunniesCount; i++ {
			bunnies[i].PositionX += bunnies[i].SpeedX * float32(delta)
			bunnies[i].PositionY += bunnies[i].SpeedY * float32(delta)

			if ((bunnies[i].PositionX + float32(texture.W)/2) > width) || ((bunnies[i].PositionX + float32(texture.W)/2) < 0) {
				bunnies[i].SpeedX *= -1
			}

			if ((bunnies[i].PositionY + float32(texture.H)/2) > width) || ((bunnies[i].PositionY + float32(texture.H)/2) < 0) {
				bunnies[i].SpeedY *= -1
			}

			var dstrect sdl.FRect
			dstrect.X = bunnies[i].PositionX
			dstrect.Y = bunnies[i].PositionY
			dstrect.W = float32(texture.W)
			dstrect.H = float32(texture.H)
			texture.SetColorMod(bunnies[i].Color.R, bunnies[i].Color.G, bunnies[i].Color.B)
			renderer.RenderTexture(texture, nil, &dstrect)
		}

		renderer.SetDrawColor(0, 0, 0, 255)
		renderer.RenderFillRect(&sdl.FRect{W: 120, H: 20})
		renderer.SetDrawColor(0, 255, 0, 255)
		renderer.DebugText(5, 5, fmt.Sprintf("bunnies %d", bunniesCount))

		renderer.Present()
	}
}

type Bunny struct {
	PositionX float32
	PositionY float32
	SpeedX    float32
	SpeedY    float32
	Color     color.RGBA
}

[Zyko0]

After testing and as expected, performance are the same with JupiterRider/purego-sdl3.
My base FPS is 240, and I added sprites until it gets down to 60 FPS and I could reach ~34k bunnies with both libraries.

Zyko0/go-sdl3 34k bunnies 60 FPS

JupiterRider/purego-sdl3 34k bunnies 60 FPS

Zyko0/go-sdl3 using RenderGeometry 200k bunnies 79 FPS

Here is to demonstrate what I was talking about by batching everything before submitting to SDL.
I went all the way to 200k and it was still above 60 FPS, because there's no CPU overhead as there are only a little (and fixed) amount of calls to the library using purego.

And here is the code:

package main

import (
	_ "embed"
	"fmt"
	"image/color"
	"math/rand"

	"github.com/Zyko0/go-sdl3/bin/binimg"
	"github.com/Zyko0/go-sdl3/bin/binsdl"
	"github.com/Zyko0/go-sdl3/img"
	sdl "github.com/Zyko0/go-sdl3/sdl"
)

const maxBunnies = 50_000*4
const width, height = 1280, 720

func main() {
	defer binsdl.Load().Unload()
	defer binimg.Load().Unload()

	defer sdl.Quit()
	if err := sdl.Init(sdl.INIT_VIDEO); err != nil {
		panic(err)
	}

	window, renderer, err := sdl.CreateWindowAndRenderer("Bunnymark", width, height, sdl.WINDOW_RESIZABLE)
	if err != nil {
		panic(err)
	}
	defer renderer.Destroy()
	defer window.Destroy()

	surface, err := img.Load("raybunny.png")
	if err != nil {
		panic(err)
	}

	texture, err := renderer.CreateTextureFromSurface(surface)
	if err != nil {
		panic(err)
	}
	defer texture.Destroy()
	surface.Destroy()

	var bunniesCount int = 0
	var bunnies [maxBunnies]Bunny
	var vertices [maxBunnies * 4]sdl.Vertex
	var indices [maxBunnies * 6]int32

	last := sdl.TicksNS()

Outer:
	for {
		var event sdl.Event
		for sdl.PollEvent(&event) {
			switch event.Type {
			case sdl.EVENT_QUIT:
				break Outer
			case sdl.EVENT_KEY_DOWN:
				evt := event.KeyboardEvent()
				if evt.Scancode == sdl.SCANCODE_ESCAPE {
					break Outer
				}
			case sdl.EVENT_MOUSE_BUTTON_DOWN:
				evt := event.MouseButtonEvent()
				if btn := evt.Button; btn == uint8(sdl.BUTTON_LEFT) {
					for i := 0; i < 100; i++ {
						if bunniesCount < maxBunnies {
							bunnies[bunniesCount].PositionX = evt.X
							bunnies[bunniesCount].PositionY = evt.Y
							bunnies[bunniesCount].SpeedX = float32(rand.Intn(501) - 250)
							bunnies[bunniesCount].SpeedY = float32(rand.Intn(501) - 250)
							bunnies[bunniesCount].Color.R = byte(rand.Intn(240+1-50) + 50)
							bunnies[bunniesCount].Color.G = byte(rand.Intn(240+1-80) + 80)
							bunnies[bunniesCount].Color.B = byte(rand.Intn(240+1-100) + 100)
							bunniesCount++
						}
					}
				}
			}
		}

		renderer.SetDrawColor(255, 255, 255, 255)
		renderer.Clear()

		now := sdl.TicksNS()
		ticks := now - last
		last = now
		delta := float64(ticks) / 1_000_000_000.0

		for i := 0; i < bunniesCount; i++ {
			bunnies[i].PositionX += bunnies[i].SpeedX * float32(delta)
			bunnies[i].PositionY += bunnies[i].SpeedY * float32(delta)

			if ((bunnies[i].PositionX + float32(texture.W)/2) > width) || ((bunnies[i].PositionX + float32(texture.W)/2) < 0) {
				bunnies[i].SpeedX *= -1
			}

			if ((bunnies[i].PositionY + float32(texture.H)/2) > width) || ((bunnies[i].PositionY + float32(texture.H)/2) < 0) {
				bunnies[i].SpeedY *= -1
			}

			clr := sdl.FColor{
				R: float32(bunnies[i].Color.R) / 255,
				G: float32(bunnies[i].Color.G) / 255,
				B: float32(bunnies[i].Color.B) / 255,
				A: 1,
			}
			vertices[i*4+0] = sdl.Vertex{
				Position: sdl.FPoint{
					X: bunnies[i].PositionX - float32(texture.W)/2,
					Y: bunnies[i].PositionY - float32(texture.H)/2,
				},
				Color: clr,
				TexCoord: sdl.FPoint{
					X: 0,
					Y: 0,
				},
			}
			vertices[i*4+1] = sdl.Vertex{
				Position: sdl.FPoint{
					X: bunnies[i].PositionX + float32(texture.W)/2,
					Y: bunnies[i].PositionY - float32(texture.H)/2,
				},
				Color: clr,
				TexCoord: sdl.FPoint{
					X: 1,
					Y: 0,
				},
			}
			vertices[i*4+2] = sdl.Vertex{
				Position: sdl.FPoint{
					X: bunnies[i].PositionX - float32(texture.W)/2,
					Y: bunnies[i].PositionY + float32(texture.H)/2,
				},
				Color: clr,
				TexCoord: sdl.FPoint{
					X: 0,
					Y: 1,
				},
			}
			vertices[i*4+3] = sdl.Vertex{
				Position: sdl.FPoint{
					X: bunnies[i].PositionX + float32(texture.W)/2,
					Y: bunnies[i].PositionY + float32(texture.H)/2,
				},
				Color: clr,
				TexCoord: sdl.FPoint{
					X: 1,
					Y: 1,
				},
			}
			indices[i*6+0] = int32(i*4 + 0)
			indices[i*6+1] = int32(i*4 + 1)
			indices[i*6+2] = int32(i*4 + 2)
			indices[i*6+3] = int32(i*4 + 1)
			indices[i*6+4] = int32(i*4 + 2)
			indices[i*6+5] = int32(i*4 + 3)
		}

		renderer.RenderGeometry(texture, vertices[:bunniesCount*4], indices[:bunniesCount*6])
		renderer.SetDrawColor(0, 0, 0, 255)
		renderer.RenderFillRect(&sdl.FRect{W: 120, H: 20})
		renderer.SetDrawColor(0, 255, 0, 255)
		renderer.DebugText(5, 5, fmt.Sprintf("bunnies %d", bunniesCount))

		renderer.Present()
	}
}

type Bunny struct {
	PositionX float32
	PositionY float32
	SpeedX    float32
	SpeedY    float32
	Color     color.RGBA
}