Rotating Pixel Art with 2x Pixels in OpenGL - c++

Question

I have a game which is using a pixel art style, upscaled so 1 pixel is equal to a 2x2 area onscreen. However, when I rotate a sprite in OpenGl it draws it using the screen pixels so it breaks the illusion of a low-res style game:
How can I rotate the sprite and draw it using the larger pixels? Right now sprites are drawn using a Sprite class with a method called Draw, and the code looks like this:
void Sprite::Draw(int x, int y, int w, int h, int tx = 0, int ty = 0, int tw = 1, int th = 1, int rotation = 0, int rx = 0, int ry = 0, int sr = 0, float r = 1, float g = 1, float b = 1) {
glEnable(GL_TEXTURE_2D);
glTranslatef(x+(w/2), y+(h/2), 0);
glRotatef((float) sr, 0.0f, 0.0f, 1.0f);
glTranslatef(-x-(w/2), -y-(h/2), 0);
glTranslatef(x+(w/2)+rx, y+(h/2)+ry, 0);
glRotatef((float) rotation, 0.0f, 0.0f, 1.0f);
glTranslatef(-(w/2)-rx, -(h/2)-ry, 0);
glColor3f(r, g, b);
glBindTexture(GL_TEXTURE_2D, texture);
const float verts[] = {
0, (float) h,
(float) w, (float) h,
0, 0,
(float) w, 0
};
const float tVerts[] = {
(float)tx/(float)width, ((float)ty+(float)th)/(float)height,
((float)tx+(float)tw)/(float)width, ((float)ty+(float)th)/(float)height,
(float)tx/(float)width, (float)ty/(float)height,
((float)tx+(float)tw)/(float)width, (float)ty/(float)height
};
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, verts);
glTexCoordPointer(2, GL_FLOAT, 0, tVerts);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glLoadIdentity();
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisable(GL_TEXTURE_2D);
}
Thanks!
EDIT: I guess I should mention I'm using SDL2 for window management.

Answer 1

You can render the whole scene at half the resolution, and then scale it up. To do this, you use a FBO (Frame Buffer Object) for your primary rendering, and then blit it to the default framebuffer.
Once, during setup, create your FBO and render target, and attach the render target to the FBO:
GLuint fboId = 0;
glGenFramebuffers(1, &fboId);
GLuint rbId = 0;
glGenRenderbuffers(1, &rbId);
// Need to bind this once so object is created.
glBindRenderbuffer(GL_RENDERBUFFER, rbId);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fboId);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbId);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
On every window resize, with the window resized to width/height, allocate the render target at half the window size. If your window is not resizable, you can combine this with the setup code:
glBindRenderbuffer(GL_RENDERBUFFER, rbId);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, width / 2, height / 2);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
On every redraw, render to the FBO, and blit the result to the default framebuffer:
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fboId);
glViewport(0, 0, width / 2, height / 2);
// draw content
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, fboId);
glBlitFramebuffer(0, 0, width / 2, height / 2,
0, 0, width, height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
The above assumes that width and height are even numbers. You may have to tweak it slightly if they can be odd.