Threading with SDL

[Salih Dincer]

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 at 79