I'm guessing that the data being used to create vert_coords is slightly wrong.
You mentioned that you use a coordinate system where the screen is 64x48 (so on a 1024x768 screen, 1 unit = 16 pixels)... When you're deciding how large each tile should be you might be making some mistakes.
In my engine I use a system where the screen is 1x1 units (so 1 horizontal unit = 1024px and 1 vertical unit = 768px).
Pixels can be interpreted a lot of different ways (they're just sample 'points')... When you're doing pixel-perfect 2D stuff though, it's best to think of them as a series of rectangles.
The vertices that make up your quads should always lie at the corners of these pixel-rectangles. As the following picture shows, vertex positions should correspond with the edges of a pixel, not the centers.
Imaginary 4x1 pixel display, with a "1 unit = 4px" vertex coordinate system.
0 .25 .5 .75 1 <-- Vertex coordinates|---|---|---|---|| 0 | 1 | 2 | 3 | <-- Pixel center coordinates|---|---|---|---|
If we wanted to draw a quad that covered pixels #1 and #2 only, the leftmost vertex would be positioned at 0.25 and the rightmost at 0.75.
Note that when finding the coordinates for a leftmost pixel, you have to find the location of that pixels left-hand edge. When finding the coordinates for a right-most pixel, you have to find the location of that pixels right-hand edge.
This is the code that I use to convert back and forth between pixel coordinates (0..1023, 0..767) and normalized (0..1, 0..1)). Normalize/Denormalize are used for any coordinates that represent widths/heights and bottom/left positions. NormalizeTR/DenormalizeTR are used for any top/right positions:
void Normalize( float& pos, float range ){ pos /= range;}void Denormalize( float& pos, float range ){ pos *= range;}void NormalizeTR( float& pos, float range ){ pos++; Normalize( pos, range );}void DenormalizeTR( float& pos, float range ){ Denormalize( pos, range ); pos--;}
Which when used in the game, produces a map like this:
And other visual objects also share this problem:
I'm still not certain as to the cause of the problem, but I have come up with a temporary solution. Our screen dimensions are stored in a coordinate system object with floating point values representing screen width and screen height. What I've discovered that is if I draw each object so that it is aligned perfectly on a pixel boundary, the drawing is always correct. So for example, if my screen resolution is 1024x768 and my coordinate system is 64x48, then one pixel length is 64/1024 = 0.0625. I adjust the draw cursor to be equal to a multiple of that value prior to drawing. (BTW, this fix works wonderful on Linux and Windows, but not OS X for some reason).
But this doesn't fix the fundamental problem, which is that our (custom made) graphics engine is rendering 2D images like this and I'm not sure why. I've tried to play with setting texture properties to GL_LINEAR and GL_NEAREST and what not, but that hasn't seemed to help any. Is there some GL property that has to be set in order to not distort the texture any when drawing it? Thanks for any advice you can give (BTW: I'm not very familiar nor experienced with OpenGL).
