diff --git a/pcmockup/debugwindow.c b/pcmockup/debugwindow.c
index d22ee71..1211bd5 100644
--- a/pcmockup/debugwindow.c
+++ b/pcmockup/debugwindow.c
@@ -9,19 +9,20 @@ struct DebugWindow
     SDL_Renderer* renderer;
     SDL_Texture* texture;
     SDL_Rect texturePos;
-    DebugInfo info;
-    xz_t position;
+    Renderer* podRenderer;
+    const DebugView* view;
+    xz_t position, offset;
     real_t zoom;
 };
 
-DebugWindow* debugWindow_init(SDL_Rect bounds, int index, const char* title)
+DebugWindow* debugWindow_init(SDL_Rect bounds, const DebugView* view, Renderer* podRenderer)
 {
     DebugWindow* me = (DebugWindow*)malloc(sizeof(DebugWindow));
     if (me == NULL)
         return NULL;
     memset(me, 0, sizeof(DebugWindow));
 
-    me->window = SDL_CreateWindow(title,
+    me->window = SDL_CreateWindow(view->name,
         bounds.x, bounds.y,
         bounds.w, bounds.h,
         SDL_WINDOW_RESIZABLE);
@@ -42,9 +43,9 @@ DebugWindow* debugWindow_init(SDL_Rect bounds, int index, const char* title)
 
     me->position = xz(real_zero, real_zero);
     me->zoom = real_one;
-    me->info.index = index;
-    me->info.offset = xz(real_from_int(bounds.w / 2), real_from_int(bounds.h / 2));
-    me->info.ren = me->renderer;
+    me->offset = xz(real_from_int(bounds.w / 2), real_from_int(bounds.h / 2));
+    me->podRenderer = podRenderer;
+    me->view = view;
     return me;
 }
 
@@ -104,6 +105,13 @@ void debugWindow_endUpdate(DebugWindow* me)
     SDL_RenderPresent(me->renderer);
 }
 
+void debugWindow_update(DebugWindow* me)
+{
+    debugWindow_startUpdate(me);
+    me->view->callback.sdl(me->podRenderer, me->renderer, me->offset, me->view->userdata);
+    debugWindow_endUpdate(me);
+}
+
 void debugWindow_handleEvent(DebugWindow* me, const SDL_Event* ev)
 {
     Uint32 windowID = SDL_GetWindowID(me->window);
@@ -128,13 +136,8 @@ void debugWindow_handleEvent(DebugWindow* me, const SDL_Event* ev)
     int textureW, textureH;
     SDL_QueryTexture(me->texture, NULL, NULL, &textureW, &textureH);
     xz_t halfSize = xz(real_from_int(textureW / 2), real_from_int(textureH / 2));
-    me->info.offset = xz_sub(
+    me->offset = xz_sub(
         xz_invScale(halfSize, me->zoom),
         me->position
     );
 }
-
-const DebugInfo* debugWindow_getDebugInfo(DebugWindow* me)
-{
-    return &me->info;
-}
diff --git a/pcmockup/debugwindowset.c b/pcmockup/debugwindowset.c
index 855e91f..6ce4bb0 100644
--- a/pcmockup/debugwindowset.c
+++ b/pcmockup/debugwindowset.c
@@ -32,8 +32,8 @@ DebugWindowSet* debugWindowSet_init(const WindowGrid* grid, Renderer* renderer)
     {
         me->windows[i] = debugWindow_init(
             windowGrid_getSingleBounds(grid, -1 - i),
-            i,
-            renderer_getDebugName(renderer, i)
+            &renderer_getDebugViews(renderer)[i],
+            renderer
         );
         if (me->windows[i] == NULL)
         {
@@ -68,10 +68,7 @@ void debugWindowSet_update(DebugWindowSet* me)
 #ifdef DEBUG_WINDOWS
     for (int i = 0; i < me->count; i++)
     {
-        debugWindow_startUpdate(me->windows[i]);
-        const DebugInfo* info = debugWindow_getDebugInfo(me->windows[i]);
-        renderer_renderDebug(me->renderer, info);
-        debugWindow_endUpdate(me->windows[i]);
+        debugWindow_update(me->windows[i]);
     }
 #endif
 }
diff --git a/pcmockup/pcmockup.h b/pcmockup/pcmockup.h
index 14bcca5..500dde8 100644
--- a/pcmockup/pcmockup.h
+++ b/pcmockup/pcmockup.h
@@ -23,12 +23,10 @@ SDL_Rect pebbleWindow_getBounds(PebbleWindow* window);
 GColor* pebbleWindow_getPebbleFramebuffer(PebbleWindow* window);
 
 typedef struct DebugWindow DebugWindow;
-DebugWindow* debugWindow_init(SDL_Rect bounds, int index, const char* title);
+DebugWindow* debugWindow_init(SDL_Rect bounds, const DebugView* debugView, Renderer* renderer);
 void debugWindow_free(DebugWindow* window);
-void debugWindow_startUpdate(DebugWindow* window);
-void debugWindow_endUpdate(DebugWindow* window);
+void debugWindow_update(DebugWindow* window);
 void debugWindow_handleEvent(DebugWindow* window, const SDL_Event* ev);
-const DebugInfo* debugWindow_getDebugInfo(DebugWindow* window);
 
 typedef struct DebugWindowSet DebugWindowSet;
 DebugWindowSet* debugWindowSet_init(const WindowGrid* grid, Renderer* renderer);
diff --git a/renderer/renderer.h b/renderer/renderer.h
index 01d83f2..77ed9f1 100644
--- a/renderer/renderer.h
+++ b/renderer/renderer.h
@@ -33,18 +33,27 @@ void renderer_moveForward(Renderer* renderer);
 void renderer_moveBackwards(Renderer* renderer);
 
 #ifdef DEBUG_WINDOWS
-#include <sdl.include.h>
+struct SDL_Renderer; // no need to include SDL here
 
-typedef struct DebugInfo
+typedef enum DebugViewType
 {
-    int index;
-    SDL_Renderer* ren;
-    xz_t offset;
-} DebugInfo;
-
-int renderer_getDebugCount(Renderer* renderer);
-const char* renderer_getDebugName(Renderer* renderer, int index);
-void renderer_renderDebug(Renderer* me, const DebugInfo* debug);
+    DebugViewType_SDL
+} DebugViewType;
+
+typedef void (*DebugViewCallback_SDL)(Renderer* me, struct SDL_Renderer* sdlRenderer, xz_t offset, const void* userdata);
+
+typedef struct DebugView
+{
+    const char* name;
+    DebugViewType type;
+    union {
+        DebugViewCallback_SDL sdl;
+    } callback;
+    const void* userdata; // given to the callbacks
+} DebugView;
+
+int renderer_getDebugCount(const Renderer* renderer);
+const DebugView* renderer_getDebugViews(const Renderer* renderer);
 #endif
 
 #endif
diff --git a/renderer/renderer_debug.c b/renderer/renderer_debug.c
index a927e52..41a8439 100644
--- a/renderer/renderer_debug.c
+++ b/renderer/renderer_debug.c
@@ -1,59 +1,53 @@
 #ifdef DEBUG_WINDOWS
 #include "renderer_internal.h"
 #include "platform.h"
+#include "sdl.include.h"
 
-int renderer_getDebugCount(Renderer* renderer)
+typedef struct
 {
-    UNUSED(renderer);
-    return 2;
-}
-
-const char* renderer_getDebugName(Renderer* renderer, int index)
-{
-    UNUSED(renderer);
-    if (index < 0 || index > 1)
-        return "";
-    static const char* const NAMES[] = {
-        "world-space",
-        "player-space"
-    };
-    return NAMES[index];
-}
+    bool_t transform;
+} RenderWorldOptions;
+static const RenderWorldOptions worldSpaceOptions = {
+    .transform = false
+};
+static const RenderWorldOptions playerSpaceOptions = {
+    .transform = true
+};
 
-void renderer_setDebugColor(const DebugInfo* debug, GColor color)
+void renderer_setDebugColor(SDL_Renderer* sdlRenderer, GColor color)
 {
-    SDL_SetRenderDrawColor(debug->ren, color.r * (255 / 3), color.g * (255 / 3), color.b * (255 / 3), 255);
+    SDL_SetRenderDrawColor(sdlRenderer, color.r * (255 / 3), color.g * (255 / 3), color.b * (255 / 3), 255);
 }
 
-void renderer_renderDebugLine(Renderer* me, const DebugInfo* debug, lineSeg_t line)
+void renderer_renderSDLDebugLine(Renderer* me, SDL_Renderer* sdlRenderer, xz_t offset, lineSeg_t line, const RenderWorldOptions* opts)
 {
     lineSeg_t transformed = line;
-    if (debug->index == 1)
+    if (opts->transform)
         renderer_transformLine(me, &line, &transformed);
-    xz_t start = xz_add(transformed.start.xz, debug->offset);
-    xz_t end = xz_add(transformed.end.xz, debug->offset);
-    SDL_RenderDrawLine(debug->ren,
+    xz_t start = xz_add(transformed.start.xz, offset);
+    xz_t end = xz_add(transformed.end.xz, offset);
+    SDL_RenderDrawLine(sdlRenderer,
         real_to_int(start.x), real_to_int(start.z),
         real_to_int(end.x), real_to_int(end.z));
 }
 
-void renderer_renderDebugVector(Renderer* me, const DebugInfo* debug, xz_t origin, xz_t direction)
+void renderer_renderDebugVector(Renderer* me, SDL_Renderer* sdlRenderer, xz_t offset, xz_t origin, xz_t direction, const RenderWorldOptions* opts)
 {
     lineSeg_t seg;
     seg.start.xz = origin;
     seg.end.xz = xz_add(origin, direction);
-    renderer_renderDebugLine(me, debug, seg);
+    renderer_renderSDLDebugLine(me, sdlRenderer, offset, seg, opts);
 
     real_t arrowLength = real_div(xz_length(direction), real_from_int(3));
     direction = xz_normalize(direction);
     xz_t arrow = xz_scale(xz_rotate(direction, real_degToRad(160)), arrowLength);
     seg.start.xz = seg.end.xz;
     seg.end.xz = xz_add(seg.start.xz, arrow);
-    renderer_renderDebugLine(me, debug, seg);
+    renderer_renderSDLDebugLine(me, sdlRenderer, offset, seg, opts);
 
     arrow = xz_scale(xz_rotate(direction, real_degToRad(-160)), arrowLength);
     seg.end.xz = xz_add(seg.start.xz, arrow);
-    renderer_renderDebugLine(me, debug, seg);
+    renderer_renderSDLDebugLine(me, sdlRenderer, offset, seg, opts);
 }
 
 xz_t angleToVector(real_t angle, real_t length)
@@ -64,8 +58,10 @@ xz_t angleToVector(real_t angle, real_t length)
     ), length);
 }
 
-void renderer_renderDebug(Renderer* me, const DebugInfo* debug)
+void renderer_debug_renderWorld(Renderer* me, SDL_Renderer* sdlRenderer, xz_t offset, const void* userdata)
 {
+    const RenderWorldOptions* opts = (const RenderWorldOptions*)userdata;
+
     const Wall* walls[] = {
         &me->wall,
         &me->wall2,
@@ -78,20 +74,47 @@ void renderer_renderDebug(Renderer* me, const DebugInfo* debug)
         lineSeg_t wallLine;
         wallLine.start.xz = (*curWall)->start;
         wallLine.end.xz = (*curWall)->end;
-        renderer_setDebugColor(debug, (*curWall)->wallColor);
-        renderer_renderDebugLine(me, debug, wallLine);
+        renderer_setDebugColor(sdlRenderer, (*curWall)->wallColor);
+        renderer_renderSDLDebugLine(me, sdlRenderer, offset, wallLine, opts);
         curWall++;
     }
 
     GColor red = GColorFromRGB(255, 0, 0);
-    renderer_setDebugColor(debug, red);
-    renderer_renderDebugVector(me, debug, me->location.position, angleToVector(me->location.angle, 30));
+    renderer_setDebugColor(sdlRenderer, red);
+    renderer_renderDebugVector(me, sdlRenderer, offset, me->location.position, angleToVector(me->location.angle, 30), opts);
     lineSeg_t fovLine;
     fovLine.start.xz = me->location.position;
     fovLine.end.xz = xz_add(me->location.position, angleToVector(me->location.angle + me->halfFov, 70));
-    renderer_renderDebugLine(me, debug, fovLine);
+    renderer_renderSDLDebugLine(me, sdlRenderer, offset, fovLine, opts);
     fovLine.end.xz = xz_add(me->location.position, angleToVector(me->location.angle - me->halfFov, 70));
-    renderer_renderDebugLine(me, debug, fovLine);
+    renderer_renderSDLDebugLine(me, sdlRenderer, offset, fovLine, opts);
+}
+
+static const DebugView debugViews[] = {
+    {
+        .name = "world-space",
+        .type = DebugViewType_SDL,
+        .callback = { .sdl = renderer_debug_renderWorld },
+        .userdata = &worldSpaceOptions
+    },
+    {
+        .name = "player-space",
+        .type = DebugViewType_SDL,
+        .callback = { .sdl = renderer_debug_renderWorld },
+        .userdata = &playerSpaceOptions
+    }
+};
+
+int renderer_getDebugCount(const Renderer* renderer)
+{
+    UNUSED(renderer);
+    return sizeof(debugViews) / sizeof(DebugView);
+}
+
+const DebugView* renderer_getDebugViews(const Renderer* renderer)
+{
+    UNUSED(renderer);
+    return debugViews;
 }
 
 #endif