fix bad copy paste

This reverts commit b712cba62d.

src/hardware/r_opengl/r_opengl.c

@@ -128,12 +128,27 @@ GLfloat projMatrix[16];
 static GLint   viewport[4];
 
 #ifdef USE_FBO_OGL
-GLuint FramebufferObject, FramebufferTexture, RenderbufferObject;
 
-boolean supportFBO = false;
+enum
+{
+	FBO_NONE,
+	FBO_ARB,
+	FBO_EXT,
+	FBO_EXT_STENCIL // supports stencil attachment
+};
+
+int supportFBO = FBO_NONE;
 static boolean fboinit = false;
 
 static void GL_Framebuffer_DeleteAttachments(void);
+
+static int FBO_FRAMEBUFFER = GL_FRAMEBUFFER;
+static int FBO_COLOR_ATTACHMENT = GL_COLOR_ATTACHMENT0;
+static int FBO_DEPTH_ATTACHMENT = GL_DEPTH_STENCIL_ATTACHMENT;
+static int FBO_DEPTH_STENCIL = GL_DEPTH24_STENCIL8;
+static int FBO_RENDERBUFFER = GL_RENDERBUFFER;
+static int FBO_COMPLETE = GL_FRAMEBUFFER_COMPLETE;
+
 #endif
 
 // Sryder:	NextTexAvail is broken for these because palette changes or changes to the texture filter or antialiasing
@@ -328,6 +343,10 @@ static void GL_MSG_Error(const char *format, ...)
 #define pglCopyTexImage2D glCopyTexImage2D
 #define pglCopyTexSubImage2D glCopyTexSubImage2D
 
+#ifdef GLDEBUGMESSAGE
+#define pglDebugMessageCallback glDebugMessageCallback
+#endif
+
 #else //!STATIC_OPENGL
 
 /* 1.0 functions */
@@ -449,7 +468,7 @@ typedef void (APIENTRY * PFNglCopyTexSubImage2D) (GLenum target, GLint level, GL
 static PFNglCopyTexSubImage2D pglCopyTexSubImage2D;
 
 #ifdef USE_FBO_OGL
-/* 3.0 functions for framebuffers and renderbuffers */
+/* core functions for framebuffers and renderbuffers */
 typedef void (APIENTRY * PFNglGenFramebuffers) (GLsizei n, GLuint *ids);
 static PFNglGenFramebuffers pglGenFramebuffers;
 typedef void (APIENTRY * PFNglBindFramebuffer) (GLenum target, GLuint framebuffer);
@@ -468,10 +487,58 @@ typedef void (APIENTRY * PFNglDeleteRenderbuffers) (GLsizei n, GLuint *renderbuf
 static PFNglDeleteRenderbuffers pglDeleteRenderbuffers;
 typedef void (APIENTRY * PFNglRenderbufferStorage) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
 static PFNglRenderbufferStorage pglRenderbufferStorage;
+
+typedef void (APIENTRY * PFNglRenderbufferStorageMultisample) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+static PFNglRenderbufferStorageMultisample pglRenderbufferStorageMultisample;
+
+typedef void (APIENTRY * PFNglBlitFramebuffer) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+static PFNglBlitFramebuffer pglBlitFramebuffer;
+
+typedef void (APIENTRY * PFNglTexImage2DMultisample) ( 	GLenum target,
+														GLsizei samples,
+														GLenum internalformat,
+														GLsizei width,
+														GLsizei height,
+														GLboolean fixedsamplelocations);
+
+static PFNglTexImage2DMultisample pglTexImage2DMultisample;
+
+
+typedef void (APIENTRY * PFNglDrawBuffer) ( 	GLenum buf);
+static PFNglDrawBuffer pglDrawBuffer;
+
+typedef void (APIENTRY * PFNglReadBuffer) ( 	GLenum mode);
+static PFNglReadBuffer pglReadBuffer;
+
 typedef void (APIENTRY * PFNglFramebufferRenderbuffer) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLenum renderbuffer);
 static PFNglFramebufferRenderbuffer pglFramebufferRenderbuffer;
+
+/* 2.1 extension functions for framebuffers and renderbuffers */
+typedef void (APIENTRY * PFNglGenFramebuffersEXT) (GLsizei n, GLuint *ids);
+static PFNglGenFramebuffersEXT pglGenFramebuffersEXT;
+typedef void (APIENTRY * PFNglBindFramebufferEXT) (GLenum target, GLuint framebuffer);
+static PFNglBindFramebufferEXT pglBindFramebufferEXT;
+typedef void (APIENTRY * PFNglDeleteFramebuffersEXT) (GLsizei n, GLuint *ids);
+static PFNglDeleteFramebuffersEXT pglDeleteFramebuffersEXT;
+typedef void (APIENTRY * PFNglFramebufferTexture2DEXT) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+static PFNglFramebufferTexture2DEXT pglFramebufferTexture2DEXT;
+typedef GLenum (APIENTRY * PFNglCheckFramebufferStatusEXT) (GLenum target);
+static PFNglCheckFramebufferStatusEXT pglCheckFramebufferStatusEXT;
+typedef void (APIENTRY * PFNglGenRenderbuffersEXT) (GLsizei n, GLuint *renderbuffers);
+static PFNglGenRenderbuffersEXT pglGenRenderbuffersEXT;
+typedef void (APIENTRY * PFNglBindRenderbufferEXT) (GLenum target, GLuint renderbuffer);
+static PFNglBindRenderbufferEXT pglBindRenderbufferEXT;
+typedef void (APIENTRY * PFNglDeleteRenderbuffersEXT) (GLsizei n, GLuint *renderbuffers);
+static PFNglDeleteRenderbuffersEXT pglDeleteRenderbuffersEXT;
+typedef void (APIENTRY * PFNglRenderbufferStorageEXT) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+static PFNglRenderbufferStorageEXT pglRenderbufferStorageEXT;
+typedef void (APIENTRY * PFNglFramebufferRenderbufferEXT) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLenum renderbuffer);
+static PFNglFramebufferRenderbufferEXT pglFramebufferRenderbufferEXT;
 #endif // USE_FBO_OGL
 
+typedef GLenum (APIENTRY * PFNglGetError) ( 	void);
+static PFNglGetError pglGetError;
+
 #endif //!STATIC_OPENGL
 
 /* 1.2 functions for 3D textures */
@@ -506,6 +573,11 @@ static PFNglColorPointer pglColorPointer;
 typedef void (APIENTRY * PFNglBlendEquation) (GLenum mode);
 static PFNglBlendEquation pglBlendEquation;
 
+#ifdef GLDEBUGMESSAGE
+typedef void (APIENTRY * PFNglDebugMessageCallback) (void (APIENTRY *DEBUGPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam), const void *userParam);
+static PFNglDebugMessageCallback pglDebugMessageCallback;
+#endif
+
 /* 1.2 Parms */
 /* GL_CLAMP_TO_EDGE_EXT */
 #ifndef GL_CLAMP_TO_EDGE
@@ -732,16 +804,35 @@ static void GL_Shader_SetUniforms(FSurfaceInfo *Surface, GLRGBAFloat *poly, GLRG
 static GLRGBAFloat shader_defaultcolor = {1.0f, 1.0f, 1.0f, 1.0f};
 
 #ifdef USE_FBO_OGL
-static boolean GLFramebuffer_CheckExt(void)
+static int GLFramebuffer_CheckExt(void)
 {
-	//this stuff needs atleast OGL 3.0
+	// in opengl 3.0 and up fbos are standart and always supported
-	if (majorGL < 3)
+	if (majorGL >= 3)
-		return false;
+		return FBO_ARB;
 
-	// check if all needed gl extensions are available
+	// gl versions from 2.1 may still support framebuffer objects
-	return (GL_isExtAvailable("GL_ARB_framebuffer_no_attachments", gl_extensions)
+
-	&& GL_isExtAvailable("GL_ARB_framebuffer_object", gl_extensions)
+	// maybe, just maybe, we support the standart extensions
-	&& GL_isExtAvailable("GL_ARB_framebuffer_sRGB", gl_extensions));
+	if (GL_isExtAvailable("GL_ARB_framebuffer_no_attachments", gl_extensions)
+		&& GL_isExtAvailable("GL_ARB_framebuffer_object", gl_extensions)
+		&& GL_isExtAvailable("GL_ARB_framebuffer_sRGB", gl_extensions))
+		return FBO_ARB;
+
+	// nope, try the older 2.1 extensions
+	if (GL_isExtAvailable("GL_EXT_framebuffer_no_attachments", gl_extensions)
+		&& GL_isExtAvailable("GL_EXT_framebuffer_object", gl_extensions)
+		&& GL_isExtAvailable("GL_EXT_framebuffer_sRGB", gl_extensions))
+	{
+		// perhaps we may even support a stencil attachment
+		if (GL_isExtAvailable("GL_EXT_packed_depth_stencil", gl_extensions))
+			return FBO_EXT_STENCIL;
+
+		// no stencil support, sad
+		return FBO_EXT;
+	}
+
+	// no fbo support for you :c
+	return FBO_NONE;
 }
 #endif
 
@@ -798,28 +889,105 @@ void SetupGLFunc4(void)
 	GetGLfunc(glUniform3fv);
 	GetGLfunc(glGetUniformLocation);
 
-#ifdef USE_FBO_OGL
+#ifdef GLDEBUGMESSAGE
-	if (GLFramebuffer_CheckExt())
+	GetGLfunc(glDebugMessageCallback);
-	{
+#endif
-		GetGLfunc(glGenFramebuffers);
-		GetGLfunc(glBindFramebuffer);
-		GetGLfunc(glDeleteFramebuffers);
-		GetGLfunc(glFramebufferTexture2D);
-		GetGLfunc(glCheckFramebufferStatus);
-		GetGLfunc(glGenRenderbuffers);
-		GetGLfunc(glBindRenderbuffer);
-		GetGLfunc(glDeleteRenderbuffers);
-		GetGLfunc(glRenderbufferStorage);
-		GetGLfunc(glFramebufferRenderbuffer);
 
-		// check if ALL functions are availible
+#ifdef USE_FBO_OGL
-		if (pglGenFramebuffers && pglBindFramebuffer &&
+	const int fbocheck = GLFramebuffer_CheckExt();
-		pglDeleteFramebuffers && pglFramebufferTexture2D &&
+
-		pglCheckFramebufferStatus && pglGenRenderbuffers &&
+	if (fbocheck != FBO_NONE)
-		pglBindRenderbuffer && pglDeleteRenderbuffers &&
+	{
-		pglRenderbufferStorage && pglFramebufferRenderbuffer)
+		if (fbocheck == FBO_ARB)
-		supportFBO = true;
+		{
+			GetGLfunc(glGenFramebuffers);
+			GetGLfunc(glBindFramebuffer);
+			GetGLfunc(glDeleteFramebuffers);
+			GetGLfunc(glFramebufferTexture2D);
+			GetGLfunc(glCheckFramebufferStatus);
+			GetGLfunc(glGenRenderbuffers);
+			GetGLfunc(glBindRenderbuffer);
+			GetGLfunc(glDeleteRenderbuffers);
+			GetGLfunc(glRenderbufferStorage);
+			GetGLfunc(glRenderbufferStorageMultisample);
+			GetGLfunc(glBlitFramebuffer);
+			GetGLfunc(glFramebufferRenderbuffer);
+			GetGLfunc(glTexImage2DMultisample);
+			GetGLfunc(glDrawBuffer);
+			GetGLfunc(glReadBuffer);
+
+			// check if ALL functions are availible
+			// what a mouthful
+			if (pglGenFramebuffers && pglBindFramebuffer &&
+				pglDeleteFramebuffers && pglFramebufferTexture2D &&
+				pglCheckFramebufferStatus && pglGenRenderbuffers &&
+				pglBindRenderbuffer && pglDeleteRenderbuffers &&
+				pglRenderbufferStorage && pglFramebufferRenderbuffer)
+				supportFBO = fbocheck;
+		}
+		else if (fbocheck == FBO_EXT || fbocheck == FBO_EXT_STENCIL) // uh oh only support for EXT prefix fbos...
+		{
+			GetGLfunc(glGenFramebuffersEXT);
+			GetGLfunc(glBindFramebufferEXT);
+			GetGLfunc(glDeleteFramebuffersEXT);
+			GetGLfunc(glFramebufferTexture2DEXT);
+			GetGLfunc(glCheckFramebufferStatusEXT);
+			GetGLfunc(glGenRenderbuffersEXT);
+			GetGLfunc(glBindRenderbufferEXT);
+			GetGLfunc(glDeleteRenderbuffersEXT);
+			GetGLfunc(glRenderbufferStorageEXT);
+			GetGLfunc(glFramebufferRenderbufferEXT);
+
+			// check if ALL functions are availible
+			// what a mouthful
+			if (pglGenFramebuffersEXT && pglBindFramebufferEXT &&
+				pglDeleteFramebuffersEXT && pglFramebufferTexture2DEXT &&
+				pglCheckFramebufferStatusEXT && pglGenRenderbuffersEXT &&
+				pglBindRenderbufferEXT && pglDeleteRenderbuffersEXT &&
+				pglRenderbufferStorageEXT && pglFramebufferRenderbufferEXT)
+			{
+				// remapping galore huehue
+				// do this so we dont have to dupe half our code
+				pglGenFramebuffers = pglGenFramebuffersEXT;
+				pglBindFramebuffer = pglBindFramebufferEXT;
+				pglDeleteFramebuffers  = pglDeleteFramebuffersEXT;
+				pglFramebufferTexture2D = pglFramebufferTexture2DEXT;
+				pglCheckFramebufferStatus = pglCheckFramebufferStatusEXT;
+				pglGenRenderbuffers = pglGenRenderbuffersEXT;
+				pglBindRenderbuffer = pglBindRenderbufferEXT;
+				pglDeleteRenderbuffers = pglDeleteRenderbuffersEXT;
+				pglRenderbufferStorage = pglRenderbufferStorageEXT;
+				pglFramebufferRenderbuffer = pglFramebufferRenderbufferEXT;
+
+				// the enums "technically" should map the same
+				// but better be safe than sorry
+				FBO_FRAMEBUFFER = GL_FRAMEBUFFER_EXT;
+				FBO_COLOR_ATTACHMENT = GL_COLOR_ATTACHMENT0_EXT;
+				FBO_DEPTH_ATTACHMENT = GL_DEPTH_ATTACHMENT_EXT;
+				FBO_DEPTH_STENCIL = (supportFBO == FBO_EXT_STENCIL) ? GL_DEPTH_STENCIL_EXT : GL_DEPTH_COMPONENT;
+				FBO_RENDERBUFFER = GL_RENDERBUFFER_EXT;
+				FBO_COMPLETE = GL_FRAMEBUFFER_COMPLETE_EXT;
+
+				supportFBO = fbocheck;
+			}
+		}
 	}
+
+	/*switch (supportFBO)
+	{
+		case FBO_ARB:
+			GL_DBG_Printf("\nFBO: ARB extensions found\n");
+			break;
+		case FBO_EXT:
+			GL_DBG_Printf("\nFBO: EXT extensions found, no stencil\n");
+			break;
+		case FBO_EXT_STENCIL:
+			GL_DBG_Printf("\nFBO: EXT extensions with packed depth-stencil\n");
+			break;
+		case FBO_NONE:
+			GL_DBG_Printf("\nFBO: No framebuffer object support\n");
+			break;
+	}*/
 #endif
 #undef GetGLfunc
 }
@@ -1063,6 +1231,53 @@ void GL_SetModelView(GLint w, GLint h)
 	pglGetFloatv(GL_PROJECTION_MATRIX, projMatrix);
 }
 
+#ifdef GLDEBUGMESSAGE
+static void APIENTRY DebugMessage(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam)
+{
+	const char *debugsource, *debugtype;
+
+	switch (source)
+	{
+#define S(s) case GL_DEBUG_SOURCE_##s: debugsource = #s; break
+		S(API);
+		S(WINDOW_SYSTEM);
+		S(SHADER_COMPILER);
+		S(THIRD_PARTY);
+		S(APPLICATION);
+		S(OTHER);
+#undef S
+	default:
+		debugsource = "unknown";
+		break;
+	}
+
+	switch (type)
+	{
+#define S(s) case GL_DEBUG_TYPE_##s: debugtype = #s; break
+		S(ERROR);
+		S(DEPRECATED_BEHAVIOR);
+		S(UNDEFINED_BEHAVIOR);
+		S(PORTABILITY);
+		S(PERFORMANCE);
+		S(MARKER);
+		S(PUSH_GROUP);
+		S(POP_GROUP);
+		S(OTHER);
+#undef S
+	default:
+		debugtype = "unknown";
+		break;
+	}
+
+	alerttype_t level = severity == GL_DEBUG_SEVERITY_HIGH ? CONS_ERROR
+	                  : severity == GL_DEBUG_SEVERITY_MEDIUM ? CONS_WARNING
+	                  : CONS_NOTICE;
+	//CONS_Alert(level, "OpenGL (%s) (%s): %s\n", debugsource, debugtype, message);
+
+	printf("OpenGL (%s) (%s): %s\n", debugsource, debugtype, message);
+}
+#endif
+
 // -----------------+
 // SetStates        : Set permanent states
 // -----------------+
@@ -1099,6 +1314,14 @@ void GL_SetStates(void)
 	pglLoadIdentity();
 	pglScalef(1.0f, 1.0f, -1.0f);
 	pglGetFloatv(GL_MODELVIEW_MATRIX, modelMatrix); // added for new coronas' code (without depth buffer)
+
+	pglEnable(GL_MULTISAMPLE);
+
+#ifdef GLDEBUGMESSAGE
+	pglEnable(GL_DEBUG_OUTPUT);
+	pglEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
+	pglDebugMessageCallback(&DebugMessage, NULL);
+#endif
 }
 
 // -----------------+
@@ -1137,48 +1360,80 @@ void GL_DeleteTexture(GLMipmap_t *pTexInfo)
 	pTexInfo->downloaded = 0;
 }
 
-#ifdef USE_FBO_OGL
+enum
-static void GL_Framebuffer_GenerateAttachments(void)
 {
-	if (!supportFBO || !UseScreenFBO())
+	FBO_RESOLV,
+	FBO_MSAA,
+};
+
+enum
+{
+	RBO_COLOR,
+	RBO_DEPTH,
+};
+
+typedef struct
+{
+	GLuint fbobject;
+	GLuint rbo[2];
+} glfbo_t;
+
+static glfbo_t FBO[2] = {};
+
+static bool fboInit = false;
+
+static void GL_Framebuffer_Generate(void)
+{
+	if (!supportFBO || fboInit)
 		return;
 
-	// Bind the framebuffer
+	if (!FBO[FBO_MSAA].fbobject)
-	pglBindFramebuffer(GL_FRAMEBUFFER, FramebufferObject);
+		pglGenFramebuffers(1, &FBO[FBO_MSAA].fbobject);
 
-	// Generate the framebuffer texture
+	pglBindFramebuffer(GL_FRAMEBUFFER, FBO[FBO_MSAA].fbobject);
-	if (!FramebufferTexture)
+
+	if (!FBO[FBO_MSAA].rbo[RBO_COLOR])
 	{
-		pglGenTextures(1, &FramebufferTexture);
+		pglGenRenderbuffers(1, &FBO[FBO_MSAA].rbo[RBO_COLOR]);
-		pglBindTexture(GL_TEXTURE_2D, FramebufferTexture);
+		pglBindRenderbuffer(GL_RENDERBUFFER, FBO[FBO_MSAA].rbo[RBO_COLOR]);
-		pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screen_width, screen_height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+		pglRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, screen_width, screen_height);
-		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		pglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, FBO[FBO_MSAA].rbo[RBO_COLOR]);
-		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-		pglBindTexture(GL_TEXTURE_2D, 0);
-
-		// Attach the framebuffer texture to the framebuffer
-		pglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, FramebufferTexture, 0);
 	}
 
-	// Generate the renderbuffer
+	if (!FBO[FBO_MSAA].rbo[RBO_DEPTH])
-	if (!RenderbufferObject)
 	{
-		pglGenRenderbuffers(1, &RenderbufferObject);
+		pglGenRenderbuffers(1, &FBO[FBO_MSAA].rbo[RBO_DEPTH]);
+		pglBindRenderbuffer(GL_RENDERBUFFER, FBO[FBO_MSAA].rbo[RBO_DEPTH]);
+		pglRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_DEPTH24_STENCIL8, screen_width, screen_height);
+		pglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, FBO[FBO_MSAA].rbo[RBO_DEPTH]);
+	}
 
-		pglBindRenderbuffer(GL_RENDERBUFFER, RenderbufferObject);
+	if (!FBO[FBO_RESOLV].fbobject)
+		pglGenFramebuffers(1, &FBO[FBO_RESOLV].fbobject);
+
+	pglBindFramebuffer(GL_FRAMEBUFFER, FBO[FBO_RESOLV].fbobject);
+
+	if (!FBO[FBO_RESOLV].rbo[RBO_COLOR])
+	{
+		pglGenRenderbuffers(1, &FBO[FBO_RESOLV].rbo[RBO_COLOR]);
+		pglBindRenderbuffer(GL_RENDERBUFFER, FBO[FBO_RESOLV].rbo[RBO_COLOR]);
+		pglRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, screen_width, screen_height);
+		pglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, FBO[FBO_RESOLV].rbo[RBO_COLOR]);
+	}
+
+	if (!FBO[FBO_RESOLV].rbo[RBO_DEPTH])
+	{
+		pglGenRenderbuffers(1, &FBO[FBO_RESOLV].rbo[RBO_DEPTH]);
+		pglBindRenderbuffer(GL_RENDERBUFFER, FBO[FBO_RESOLV].rbo[RBO_DEPTH]);
 		pglRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, screen_width, screen_height);
-		pglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, RenderbufferObject);
+		pglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, FBO[FBO_RESOLV].rbo[RBO_DEPTH]);
-
-		// Clear the renderbuffer
-		GL_ClearBuffer(true, true, true, NULL);
-
-		pglBindRenderbuffer(GL_RENDERBUFFER, 0);
 	}
 
-	// Unbind the framebuffer
+	// unbind
 	pglBindFramebuffer(GL_FRAMEBUFFER, 0);
+	pglBindRenderbuffer(GL_RENDERBUFFER, 0);
 
-	fboinit = true;
+	fboInit = true;
 }
 
 static void GL_Framebuffer_DeleteAttachments(void)
@@ -1186,47 +1441,51 @@ static void GL_Framebuffer_DeleteAttachments(void)
 	if (!supportFBO || !fboinit)
 		return;
 
-	if (!FramebufferObject && !RenderbufferObject && !FramebufferTexture)
+	if (FBO[FBO_MSAA].rbo[RBO_COLOR])
-		return;
+	{
+		pglDeleteRenderbuffers(1, &FBO[FBO_MSAA].rbo[RBO_COLOR]);
+		FBO[FBO_MSAA].rbo[RBO_COLOR] = 0;
+	}
 
-	// Unbind the framebuffer
+	if (FBO[FBO_MSAA].rbo[RBO_DEPTH])
-	pglBindFramebuffer(GL_FRAMEBUFFER, 0);
+	{
-	pglBindRenderbuffer(GL_RENDERBUFFER, 0);
+		pglDeleteRenderbuffers(1, &FBO[FBO_MSAA].rbo[RBO_DEPTH]);
+		FBO[FBO_MSAA].rbo[RBO_DEPTH] = 0;
+	}
 
-	if (FramebufferTexture)
+	if (FBO[FBO_RESOLV].rbo[RBO_COLOR])
-		pglDeleteTextures(1, &FramebufferTexture);
+	{
+		pglDeleteRenderbuffers(1, &FBO[FBO_RESOLV].rbo[RBO_COLOR]);
+		FBO[FBO_RESOLV].rbo[RBO_COLOR] = 0;
+	}
 
-	if (RenderbufferObject)
+	if (FBO[FBO_RESOLV].rbo[RBO_DEPTH])
-		pglDeleteRenderbuffers(1, &RenderbufferObject);
+	{
+		pglDeleteRenderbuffers(1, &FBO[FBO_RESOLV].rbo[RBO_DEPTH]);
+		FBO[FBO_RESOLV].rbo[RBO_DEPTH] = 0;
+	}
 
-	FramebufferTexture = 0;
+	fboInit = false;
-	RenderbufferObject = 0;
-	fboinit = false;
-}
-
-static void GL_Framebuffer_Generate(void)
-{
-	if (!supportFBO || !UseScreenFBO())
-		return;
-
-	// Generate the framebuffer
-	if (!FramebufferObject)
-		pglGenFramebuffers(1, &FramebufferObject);
-
-	if (pglCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE)
-		GL_Framebuffer_GenerateAttachments();
 }
 
 static void GL_Framebuffer_Delete(void)
 {
-	if (!supportFBO || !fboinit)
+	if (!supportFBO)
 		return;
 
-	if (FramebufferObject)
-		pglDeleteFramebuffers(1, &FramebufferObject);
-
 	GL_Framebuffer_DeleteAttachments();
-	FramebufferObject = 0;
+
+	if (FBO[FBO_MSAA].fbobject)
+	{
+		pglDeleteFramebuffers(1, &FBO[FBO_MSAA].fbobject);
+		FBO[FBO_MSAA].fbobject = 0;
+	}
+
+	if (FBO[FBO_RESOLV].fbobject)
+	{
+		pglDeleteFramebuffers(1, &FBO[FBO_RESOLV].fbobject);
+		FBO[FBO_RESOLV].fbobject = 0;
+	}
 }
 
 void GL_Framebuffer_Unbind(void)
@@ -1234,41 +1493,36 @@ void GL_Framebuffer_Unbind(void)
 	if (!supportFBO || !fboinit)
 		return;
 
-	if (!FramebufferObject && !RenderbufferObject)
+	pglBindFramebuffer(GL_READ_FRAMEBUFFER, FBO[FBO_MSAA].fbobject);
-		return;
+	pglBindFramebuffer(GL_DRAW_FRAMEBUFFER, FBO[FBO_RESOLV].fbobject);
 
+	pglBlitFramebuffer(0, 0, screen_width, screen_height,
+						0, 0, screen_width, screen_height,
+						GL_COLOR_BUFFER_BIT,
+						GL_NEAREST);
+
+	// back to default framebuffer
 	pglBindFramebuffer(GL_FRAMEBUFFER, 0);
-	pglBindRenderbuffer(GL_RENDERBUFFER, 0);
 }
 
 void GL_Framebuffer_Enable(void)
 {
-	if (!supportFBO || !UseScreenFBO())
+	if (!supportFBO)
 		return;
 
-	if (FramebufferObject == 0)
+	GL_Framebuffer_Generate();
-		GL_Framebuffer_Generate();
+	pglBindFramebuffer(GL_FRAMEBUFFER, FBO[FBO_MSAA].fbobject);
-	else if (!FramebufferTexture || !RenderbufferObject)
-		GL_Framebuffer_GenerateAttachments();
-
-	pglBindFramebuffer(GL_FRAMEBUFFER, FramebufferObject);
-	pglBindRenderbuffer(GL_RENDERBUFFER, RenderbufferObject);
 }
 
 void GL_Framebuffer_Disable(void)
 {
-	if (!supportFBO || !fboinit)
+	if (!supportFBO)
-		return;
-
-	if (!FramebufferObject && !RenderbufferObject)
 		return;
 
 	pglBindFramebuffer(GL_FRAMEBUFFER, 0);
-	pglBindRenderbuffer(GL_RENDERBUFFER, 0);
-
 	GL_Framebuffer_Delete();
 }
-#endif
+
 
 // -----------------+
 // Flush            : flush OpenGL textures

src/hardware/r_opengl/r_opengl.h

@@ -111,9 +111,8 @@ void GL_Framebuffer_Unbind(void);
 void GL_Framebuffer_Enable(void);
 void GL_Framebuffer_Disable(void);
 
-extern GLuint FramebufferObject, FramebufferTexture, RenderbufferObject;
 extern GLboolean FrameBufferEnabled, RenderToFramebuffer;
-extern boolean supportFBO;
+extern int supportFBO;
 #endif
 
 // ==========================================================================

src/sdl/ogl_sdl.c

@@ -71,18 +71,9 @@ PFNglGetString pglGetString;
 #endif
 
 #ifdef USE_FBO_OGL
-
-#if defined (__unix__)
-static boolean xwaylandcrap = false;
-#endif
-
 boolean UseScreenFBO(void)
 {
-	return ((supportFBO && cv_glframebuffer.value && downsample)
+	return (supportFBO && cv_glframebuffer.value);
-#if defined (__unix__)
-	|| (supportFBO && xwaylandcrap)
-#endif
-	);
 }
 #endif
 
@@ -207,16 +198,6 @@ boolean OglSdlSurface(INT32 w, INT32 h)
 			maximumAnisotropy = 1;
 
 		glanisotropicmode_cons_t[1].value = maximumAnisotropy;
-
-#if defined (__unix__)
-#ifdef USE_FBO_OGL
-		char videodriver[4] = {'S','D','L',0};
-		if (supportFBO && strstr((const char*)gl_renderer, "NVIDIA")
-			&& (*strncpy(videodriver, SDL_GetCurrentVideoDriver(), sizeof(videodriver)-1) != '\0')
-			&& (strncasecmp("x11",videodriver,4) == 0))
-			xwaylandcrap = true;
-#endif
-#endif
 	}
 
 	SDL_GL_SetSwapInterval(cv_vidwait.value ? 1 : 0);
@@ -294,13 +275,6 @@ void OglSdlFinishUpdate(boolean waitvbl)
 	if (!I_CheckNativeRes() || WipeInAction)
 #endif
 		HWR_DrawScreenFinalTexture(realwidth, realheight, false);
-
-#if defined (__unix__)
-#ifdef USE_FBO_OGL
-	if (loaded_config)
-		xwaylandcrap = false;
-#endif
-#endif
 }
 
 #endif //HWRENDER