Re: Threading with SDL

[Salih Dincer via Digitalmars-d-learn]

On Tuesday, 19 November 2024 at 09:08:46 UTC, Adrian Preuß wrote:

I have the following project structure:
```
    - main.d (Booting)
    - client.d
    - Renderer.d
        - Manager
            - SDL2.d
            - GLFW.d
        - RenderingTargets
            - DirectX.d
            - Vulkan.d
            - OpenGL.d
```

```d
module game.main;

import core.thread;
import core.sync.semaphore;
import std.stdio;
import std.concurrency;

// Renderer interface
abstract class Renderer {
    private bool isRunning = true;
    protected Tid mainThreadId;

    this(Tid mainThreadId) {
        this.mainThreadId = mainThreadId;
    }

    void initialize() {
        // Initialization logic
    }

    void run() {
        while (isRunning) {
            // Rendering loop
            renderFrame();
        }
    }

    protected void renderFrame() {
        // Implement rendering logic
    }

    void stop() {
        isRunning = false;
    }
}

// SDL2 Specific Renderer
class SDL2Renderer : Renderer {
    this(Tid mainThreadId) {
        super(mainThreadId);
    }

    override void initialize() {
        // SDL2 specific initialization
        import derelict.sdl2.sdl;
        DerelictSDL2.load();

        SDL_Init(SDL_INIT_VIDEO);
        // Create window, context, etc.
    }

    override protected void renderFrame() {
        import derelict.sdl2.sdl;

        SDL_Event event;
        while (SDL_PollEvent(&event)) {
            switch (event.type) {
                case SDL_QUIT:
                    send(mainThreadId, "renderer_stopped");
                    stop();
                    break;
                default:
                    break;
            }
        }

        // Actual rendering logic
        // SDL_GL_SwapWindow(), etc.
    }
}

// Game Client
class GameClient {
    private Renderer renderer;
    private Tid rendererThread;

    this() {
        // Create a thread for rendering
        rendererThread = spawn(&rendererLoop, thisTid);
    }

    private void rendererLoop() {
        // Initialize renderer on its own thread
        auto sdlRenderer = new SDL2Renderer(thisTid);
        sdlRenderer.initialize();
        sdlRenderer.run();
    }

    void run() {
        // Main game loop
        while (true) {
            // Non-blocking game logic
            updateGameState();

            // Check for renderer messages
            receiveTimeout(
                dur!"msecs"(10),
                (string msg) {
                    if (msg == "renderer_stopped") {
                        break;
                    }
                }
            );
        }
    }

    private void updateGameState() {
        // Game state update logic
        // This runs independently of rendering
    }

    void shutdown() {
        // Send stop signal to renderer thread
        send(rendererThread, "stop");
    }
}

// Main entry point
void main() {
    auto game = new GameClient();
    game.run();
}
```

SDB@79