Add r_framebuffer_get_size; abstract away SDL_GL_GetDrawableSize

src/renderer/api.c

@@ -501,6 +501,10 @@ void r_framebuffer(Framebuffer *fb) {
 	B.framebuffer(fb);
 }
 
+IntExtent r_framebuffer_get_size(Framebuffer *fb) {
+	return B.framebuffer_get_size(fb);
+}
+
 Framebuffer * r_framebuffer_current(void) {
 	return B.framebuffer_current();
 }

src/renderer/api.h

@@ -680,6 +680,7 @@ void r_framebuffer_viewport_rect(Framebuffer *fb, FloatRect viewport);
 void r_framebuffer_viewport_current(Framebuffer *fb, FloatRect *viewport) attr_nonnull(2);
 void r_framebuffer_destroy(Framebuffer *fb) attr_nonnull(1);
 void r_framebuffer_clear(Framebuffer *fb, ClearBufferFlags flags, const Color *colorval, float depthval);
+IntExtent r_framebuffer_get_size(Framebuffer *fb);
 
 void r_framebuffer(Framebuffer *fb);
 Framebuffer* r_framebuffer_current(void);

src/renderer/common/backend.h

@@ -82,6 +82,7 @@ typedef struct RendererFuncs {
 	Texture* (*framebuffer_get_attachment)(Framebuffer *framebuffer, FramebufferAttachment attachment);
 	uint (*framebuffer_get_attachment_mipmap)(Framebuffer *framebuffer, FramebufferAttachment attachment);
 	void (*framebuffer_clear)(Framebuffer *framebuffer, ClearBufferFlags flags, const Color *colorval, float depthval);
+	IntExtent (*framebuffer_get_size)(Framebuffer *framebuffer);
 
 	void (*framebuffer)(Framebuffer *framebuffer);
 	Framebuffer* (*framebuffer_current)(void);

src/renderer/gl33/framebuffer.c

@@ -154,3 +154,33 @@ void gl33_framebuffer_clear(Framebuffer *framebuffer, ClearBufferFlags flags, co
 	glClear(glflags);
 	r_framebuffer(fb_saved);
 }
+
+IntExtent gl33_framebuffer_get_effective_size(Framebuffer *framebuffer) {
+	// According to the OpenGL wiki:
+	// "The effective size of the FBO is the intersection of all of the sizes of the bound images (ie: the smallest in each dimension)."
+
+	// TODO: do it once in gl33_framebuffer_prepare and cache the result
+
+	IntExtent fb_size = { 0, 0 };
+
+	for(int i = 0; i < FRAMEBUFFER_MAX_ATTACHMENTS; ++i) {
+		Texture *tex = gl33_framebuffer_get_attachment(framebuffer, i);
+
+		if(tex != NULL) {
+			uint mipmap = framebuffer->attachment_mipmaps[i];
+			uint tex_w, tex_h;
+			gl33_texture_get_size(tex, mipmap, &tex_w, &tex_h);
+			IntExtent tex_size = { tex_w, tex_h };
+
+			if(fb_size.w == 0 && fb_size.h == 0) {
+				fb_size = tex_size;
+			} else if(tex_size.w < fb_size.w) {
+				fb_size.w = tex_size.w;
+			} else if(tex_size.h < fb_size.h) {
+				fb_size.h = tex_size.h;
+			}
+		}
+	}
+
+	return fb_size;
+}

src/renderer/gl33/framebuffer.h

@@ -33,6 +33,7 @@ uint gl33_framebuffer_get_attachment_mipmap(Framebuffer *framebuffer, Framebuffe
 void gl33_framebuffer_destroy(Framebuffer *framebuffer);
 void gl33_framebuffer_taint(Framebuffer *framebuffer);
 void gl33_framebuffer_clear(Framebuffer *framebuffer, ClearBufferFlags flags, const Color *colorval, float depthval);
+IntExtent gl33_framebuffer_get_effective_size(Framebuffer *framebuffer);
 void gl33_framebuffer_set_debug_label(Framebuffer *fb, const char *label);
 const char* gl33_framebuffer_get_debug_label(Framebuffer* fb);
 

src/renderer/gl33/gl33.c

@@ -111,6 +111,7 @@ static struct {
 	r_feature_bits_t features;
 
 	SDL_GLContext *gl_context;
+	SDL_Window *window;
 
 	#ifdef GL33_DRAW_STATS
 	struct {
@@ -901,6 +902,7 @@ static SDL_Window* gl33_create_window(const char *title, int x, int y, int w, in
 		GLVT.init_context(window);
 	}
 
+	R.window = window;
 	return window;
 }
 
@@ -1050,6 +1052,19 @@ static void gl33_framebuffer_viewport_current(Framebuffer *fb, FloatRect *out_re
 	transform_viewport_origin(fb, out_rect);
 }
 
+static IntExtent gl33_framebuffer_get_size(Framebuffer *fb) {
+	IntExtent fb_size;
+
+	if(fb == NULL) {
+		// TODO: cache this at window creation time and refresh on resize events?
+		SDL_GL_GetDrawableSize(R.window, &fb_size.w, &fb_size.h);
+	} else {
+		fb_size = gl33_framebuffer_get_effective_size(fb);
+	}
+
+	return fb_size;
+}
+
 static void gl33_shader(ShaderProgram *prog) {
 	assert(prog->gl_handle != 0);
 
@@ -1187,6 +1202,7 @@ RendererBackend _r_backend_gl33 = {
 		.framebuffer = gl33_framebuffer,
 		.framebuffer_current = gl33_framebuffer_current,
 		.framebuffer_clear = gl33_framebuffer_clear,
+		.framebuffer_get_size = gl33_framebuffer_get_size,
 		.vertex_buffer_create = gl33_vertex_buffer_create,
 		.vertex_buffer_set_debug_label = gl33_vertex_buffer_set_debug_label,
 		.vertex_buffer_get_debug_label = gl33_vertex_buffer_get_debug_label,

src/renderer/null/null.c

@@ -105,6 +105,7 @@ static void null_framebuffer_viewport_current(Framebuffer *framebuffer, FloatRec
 static void null_framebuffer(Framebuffer *framebuffer) { }
 static Framebuffer* null_framebuffer_current(void) { return (void*)&placeholder; }
 static void null_framebuffer_clear(Framebuffer *framebuffer, ClearBufferFlags flags, const Color *colorval, float depthval) { }
+static IntExtent null_framebuffer_get_size(Framebuffer *framebuffer) { return (IntExtent) { 64, 64 }; }
 
 static int64_t null_vertex_buffer_stream_seek(SDL_RWops *rw, int64_t offset, int whence) { return 0; }
 static int64_t null_vertex_buffer_stream_size(SDL_RWops *rw) { return (1 << 16); }
@@ -218,6 +219,7 @@ RendererBackend _r_backend_null = {
 		.framebuffer = null_framebuffer,
 		.framebuffer_current = null_framebuffer_current,
 		.framebuffer_clear = null_framebuffer_clear,
+		.framebuffer_get_size = null_framebuffer_get_size,
 		.vertex_buffer_create = null_vertex_buffer_create,
 		.vertex_buffer_get_debug_label = null_vertex_buffer_get_debug_label,
 		.vertex_buffer_set_debug_label = null_vertex_buffer_set_debug_label,

src/video.c

@@ -128,13 +128,11 @@ static int video_compare_modes(const void *a, const void *b) {
 	return va->width * va->height - vb->width * vb->height;
 }
 
-static FloatExtent video_get_screen_framebuffer_size(void) {
-	int fb_w, fb_h;
-	SDL_GL_GetDrawableSize(video.window, &fb_w, &fb_h);
-	return (FloatExtent) { fb_w, fb_h };
+static IntExtent video_get_screen_framebuffer_size(void) {
+	return r_framebuffer_get_size(video_get_screen_framebuffer());
 }
 
-static FloatExtent video_get_viewport_size_for_framebuffer(FloatExtent framebuffer_size) {
+static FloatExtent video_get_viewport_size_for_framebuffer(IntExtent framebuffer_size) {
 	float w = framebuffer_size.w;
 	float h = framebuffer_size.h;
 	float r = w / h;
@@ -149,17 +147,17 @@ static FloatExtent video_get_viewport_size_for_framebuffer(FloatExtent framebuff
 }
 
 void video_get_viewport_size(float *width, float *height) {
-	FloatExtent fb = video_get_screen_framebuffer_size();
+	IntExtent fb = video_get_screen_framebuffer_size();
 	FloatExtent vp = video_get_viewport_size_for_framebuffer(fb);
 
 	*width = vp.w;
 	*height = vp.h;
 }
 
 void video_get_viewport(FloatRect *vp) {
-	FloatExtent fb = video_get_screen_framebuffer_size();
+	IntExtent fb = video_get_screen_framebuffer_size();
 
-	// vp->extent aliases vp->w and vp->y; see util/geometry.h
+	// vp->extent aliases vp->w and vp->h; see util/geometry.h
 	vp->extent = video_get_viewport_size_for_framebuffer(fb);
 
 	vp->x = (int)((fb.w - vp->w) * 0.5);
@@ -735,7 +733,7 @@ void video_init(void) {
 				fullscreen_available = true;
 
 				if(has_windowed_modes) {
-					FloatExtent vp = video_get_viewport_size_for_framebuffer((FloatExtent) { mode.w, mode.h });
+					FloatExtent vp = video_get_viewport_size_for_framebuffer((IntExtent) { mode.w, mode.h });
 					video_add_mode_windowed(vp.w, vp.h);
 
 					// the ratio is always constant, so we need to check only 1 dimension