View difference between Paste ID: 1uVT7VkR and dBXgjrUX

 #include "RenderTarget.h"
 #include "Context.h"
 #include <math.h>
 #include <stdio.h>
 
 #include "Helper.h" // remove this
 
 RenderTarget::Viewport RenderTarget::viewport;
 
 RenderTarget::RenderTarget(GLint width, GLint height, GLint texCount)
 {
 	rot = 0;
 
 	size.x = width;
 	size.y = height;
 	this->texCount = texCount;
 	windowSize.x = Context::getWindowWidth();
 	windowSize.y = Context::getWindowHeight();
 
 	// Create and initialize framebuffer
 	texRT = new GLuint[texCount];
 
 	GLint prev_bound_texture;
-	glBindFramebuffer(GL_FRAMEBUFFER, frameBufferRT);
+	glGetInteger(GL_TEXTURE_BINDING_2D, &prev_bound_texture);
 	glGenTextures(texCount, texRT);
 	for(int i = 0; i < texCount; i ++)
 	{
 		glBindTexture(GL_TEXTURE_2D, texRT[i]);
 		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 	}
-		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, texRT[i], 0);
+	glBindTexture(GL_TEXTURE_2D, 0);
 
 	glGenFramebuffers(1, &frameBufferRT);
 
 	printf("+ RenderTarget added\n");
 }
 
 RenderTarget::~RenderTarget()
 {
 	printf("- RenderTarget deleted\n");
 	delete[] texRT;
 }
 
 void RenderTarget::Begin()
 {
 	// Setup framebuffer
 	glGetIntegerv(GL_VIEWPORT, viewport.vp);
 	glViewport(0, size.y - windowSize.y, windowSize.x, windowSize.y);
-	glBindFramebuffer(GL_FRAMEBUFFER, frameBufferRT);
+
 	GLint max_texture_image_units, active_unit;
 	glGetInteger(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_image_units);
 	glGetInteger(GL_ACTIVE_TEXTURE, &active_unit); // yes I know the naming is odd
-		GLenum* buffers = new GLenum[texCount];
+
 	{
 		for (GLuint i = 0; i < texCount; i++)
 		{
 			// make sure RT textures are unbound before attaching
 			for(GLuint u = 0; u < max_texture_image_units; u++) {
 				GLuint bound_texture;
 				glActiveTexture(GL_TEXTURE0 + u);
 				glGetInteger(GL_TEXTURE_BINDING_2D, &bound_texture);
 				if(bound_texture = texRT[i]) {
 					// better yet, store (unit,texture) pairs, so that we can restore in RenderTarget::End.
 					glBindTexture(GL_TEXTURE_2D, 0);
 				}
 			}
 		}
 
 		glActiveTexture(active_unit); //okay, this is a kludge. Ideally the code rendering to the FBO takes care of this. But if now, we fail safely.
 
 		GLenum* buffers = new GLenum[texCount];
 		glBindFramebuffer(GL_FRAMEBUFFER, frameBufferRT);
 		for (GLuint i = 0; i < texCount; i++)
 		{
 			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, texRT[i], 0);
 			buffers[i] = GL_COLOR_ATTACHMENT0 + i;
 		}
 		glDrawBuffers(texCount, buffers);
 		delete[] buffers;
 	}
 
 	// vvvv Those should not be here, but in the part actually rendering to the FBO
 
 	// Set blend-mode
 	glDisable(GL_BLEND);
 
 	// Clear the buffer
 	glClearColor(0.0, 0.0, 0.0, 0.0);
 	glClear(GL_COLOR_BUFFER_BIT);
 }
 
 void RenderTarget::End()
 {
 	// Reset blend-mode
 	glEnable(GL_BLEND);
 
 	// Reset framebuffer
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
 	// Reset viewport
 	glViewport(viewport.x, viewport.y, viewport.width, viewport.height);
 }
 
 void RenderTarget::Draw(GLint x, GLint y)
 {
 	Draw(x, y, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0, 0, size.x, size.y);
 }
 
 void RenderTarget::Draw(GLint x, GLint y, GLfloat alpha)
 {
 	Draw(x, y, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, alpha, 0, 0, size.x, size.y);
 }
 
 void RenderTarget::Draw(GLint x, GLint y, GLfloat rotation, GLfloat scaleX, GLfloat scaleY, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha, GLint xx, GLint yy, GLint w, GLint h)
 {
 	// Draw the framebuffer-texture
 	// Bind texture
 	glBindTexture(GL_TEXTURE_2D, texRT[0]);
 
 	// Push the matrix
 	glPushMatrix();
 
 	// Rotate and translate the quad
 	glTranslatef(x, y, 0.0f);
 	glRotatef(rotation, 0.0f, 0.0f, 1.0f);
 
 	// Calculate coordinates
 	GLdouble coX1, coX2, coY1, coY2;
 	coX1 = (GLdouble)xx / size.x;
 	coY1 = (GLdouble)yy / size.y;
 	coX2 = (GLdouble)(xx + w) / size.x;
 	coY2 = (GLdouble)(yy + h) / size.y;
 
 	// Testing blend functions
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
 	// Draw the textured quad
 	glBegin(GL_QUADS);
 	glColor4f(red, green, blue, alpha);
 
 	glTexCoord2d(coX1, coY2); glVertex2d(0,				0);
 	glTexCoord2d(coX2, coY2); glVertex2d(w * scaleX,	0);
 	glTexCoord2d(coX2, coY1); glVertex2d(w * scaleX,	h * scaleY);
 	glTexCoord2d(coX1, coY1); glVertex2d(0,				h * scaleY);
 	//glTexCoord2d(coX1, coY2); glVertex2d(lenDirX(5, rot * 2), lenDirY(5, rot * 3));
 	//glTexCoord2d(coX2, coY2); glVertex2d(w * scaleX + lenDirX(5, rot),	lenDirX(5, rot * 4));
 	//glTexCoord2d(coX2, coY1); glVertex2d(w * scaleX + lenDirY(5, rot * 4),	h * scaleY + lenDirX(5, rot));
 	//glTexCoord2d(coX1, coY1); glVertex2d(lenDirX(-5, rot * 3),				h * scaleY + lenDirX(-5, rot * 2));
 	glEnd();
 
 	// Return to default blend-function
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
 	// Pop the matrix
 	glPopMatrix();
 
 	rot += 0.5f;
 }
 
 // Get size of rendertarget
 Point RenderTarget::GetSize()
 {
 	return size;
 }