I have my regular GUI code looking the way I expect it to. However, due to certain optimization requirements, I'm now trying to double buffer portions of my GL-drawn window controls. This has brought up an unexpected surprise - there are minor differences between the double buffered and the directly drawn graphics.

Attached are two images - the first one is the direct draw result and the second one is unscaled FBO output blitted into the frame buffer (a matching quad drawn in ortho mode). Images are captured via PrintScreen, not copied from the GPU. I've blown them up 400% (no interpolation) to accentuate the minuscule changes - notably the corners of the rects are visibly different, even at 100%.

The FBO target has filter mode set to GL_NEAREST for both min and max, it's a 32 bit non-float RGBA image (same as the frame buffer) and mipmaps are disabled.

It's hard to post code unless I know where to look as everything's neck-deep in a larger framework.

I'm probably missing something really obvious here so if anyone can point it out, that'd be awesome

Note - the one-pixel vertical blur on the right of the rects in the first image is due to a 0.1 subpixel shift to emulate slight antialiasing. Looks better at 100%.

[attachment=11216:gui1.png][attachment=11217:gui2.png]
[attachment=11220:gsl3.png]
Edit: added the third screenshot of a GL_LINEAR/GL_LINEAR target.

I have my regular GUI code looking the way I expect it to. However, due to certain optimization requirements, I'm now trying to double buffer portions of my GL-drawn window controls. This has brought up an unexpected surprise - there are minor differences between the double buffered and the directly drawn graphics.

Attached are two images - the first one is the direct draw result and the second one is unscaled FBO output blitted into the frame buffer (a matching quad drawn in ortho mode). Images are captured via PrintScreen, not copied from the GPU. I've blown them up 400% (no interpolation) to accentuate the minuscule changes - notably the corners of the rects are visibly different, even at 100%.

The FBO target has filter mode set to GL_NEAREST for both min and max, it's a 32 bit non-float RGBA image (same as the frame buffer) and mipmaps are disabled.

It's hard to post code unless I know where to look as everything's neck-deep in a larger framework.

I'm probably missing something really obvious here so if anyone can point it out, that'd be awesome

Note - the one-pixel vertical blur on the right of the rects in the first image is due to a 0.1 subpixel shift to emulate slight antialiasing. Looks better at 100%.

[attachment=11216:gui1.png][attachment=11217:gui2.png]
[attachment=11220:gsl3.png]

I have my regular GUI code looking the way I expect it to. However, due to certain optimization requirements, I'm now trying to double buffer portions of my GL-drawn window controls. This has brought up an unexpected surprise - there are minor differences between the double buffered and the directly drawn graphics.

Attached are two images - the first one is the direct draw result and the second one is unscaled FBO output blitted into the frame buffer (a matching quad drawn in ortho mode). Images are captured via PrintScreen, not copied from the GPU. I've blown them up 400% (no interpolation) to accentuate the minuscule changes - notably the corners of the rects are visibly different, even at 100%.

The FBO target has filter mode set to GL_NEAREST for both min and max, it's a 32 bit non-float RGBA image (same as the frame buffer) and mipmaps are disabled.

It's hard to post code unless I know where to look as everything's neck-deep in a larger framework.

I'm probably missing something really obvious here so if anyone can point it out, that'd be awesome

Note - the one-pixel vertical blur on the right of the rects in the first image is due to a 0.1 subpixel shift to emulate slight antialiasing. Looks better at 100%.

[attachment=11216:gui1.png][attachment=11217:gui2.png]
[attachment=11220:gsl3.png]

I have my regular GUI code looking the way I expect it to. However, due to certain optimization requirements, I'm now trying to double buffer portions of my GL-drawn window controls. This has brought up an unexpected surprise - there are minor differences between the double buffered and the directly drawn graphics.

Attached are two images - the first one is the direct draw result and the second one is unscaled FBO output blitted into the frame buffer (a matching quad drawn in ortho mode). Images are captured via PrintScreen, not copied from the GPU. I've blown them up 400% (no interpolation) to accentuate the minuscule changes - notably the corners of the rects are visibly different, even at 100%.

The FBO target has filter mode set to GL_NEAREST for both min and max, it's a 32 bit non-float RGBA image (same as the frame buffer) and mipmaps are disabled.

It's hard to post code unless I know where to look as everything's neck-deep in a larger framework.

I'm probably missing something really obvious here so if anyone can point it out, that'd be awesome

Note - the one-pixel vertical blur on the right of the rects in the first image is due to a 0.1 subpixel shift to emulate slight antialiasing. Looks better at 100%.

[attachment=11216:gui1.png][attachment=11217:gui2.png]

I have my regular GUI code looking the way I expect it to. However, due to certain optimization requirements, I'm now trying to double buffer portions of my GL-drawn window controls. This has brought up an unexpected surprise - there are minor differences between the double buffered and the directly drawn graphics.

Attached are two images - the first one is the direct draw result and the second one is unscaled FBO output blitted into the frame buffer (a matching quad drawn in ortho mode). Images are captured via PrintScreen, not copied from the GPU. I've blown them up 400% (no interpolation) to accentuate the minuscule changes - notably the corners of the rects are visibly different, even at 100%.

The FBO target has filter mode set to GL_NEAREST for both min and max, it's a 32 bit non-float RGBA image (same as the frame buffer) and mipmaps are disabled.

It's hard to post code unless I know where to look as everything's neck-deep in a larger framework.

I'm probably missing something really obvious here so if anyone can point it out, that'd be awesome

Note - the one-pixel vertical blur on the right of the rects in the first image is due to a 0.1 subpixel shift to emulate slight antialiasing. Looks better at 100%.

[attachment=11216:gui1.png][attachment=11217:gui2.png]

EDIT: the tile of the topic is misleading and my aim isn't to achieve pixel-perfect reproduction in OpenGL. However, here's a disclaimer as apparently I can't change the title!

I have my regular GUI code looking the way I expect it to. However, due to certain optimization requirements, I'm now trying to double buffer portions of my GL-drawn window controls. This has brought up an unexpected surprise - there are minor differences between the double buffered and the directly drawn graphics.

Attached are two images - the first one is the direct draw result and the second one is unscaled FBO output blitted into the frame buffer (a matching quad drawn in ortho mode). Images are captured via PrintScreen, not copied from the GPU. I've blown them up 400% (no interpolation) to accentuate the minuscule changes - notably the corners of the rects are visibly different, even at 100%.

The FBO target has filter mode set to GL_NEAREST for both min and max, it's a 32 bit non-float RGBA image (same as the frame buffer) and mipmaps are disabled.

It's hard to post code unless I know where to look as everything's neck-deep in a larger framework.

I'm probably missing something really obvious here so if anyone can point it out, that'd be awesome

Note - the one-pixel vertical blur on the right of the rects in the first image is due to a 0.1 subpixel shift to emulate slight antialiasing. Looks better at 100%.

[attachment=11216:gui1.png][attachment=11217:gui2.png]