OpenGL from what I've learned is incredibly difficult to do accurate 2D placement with, possible but difficult. The fact that most web-tutorials/e-books for it aren't very good, and most books I've found at my local book-stores are for Advanced OpenGL and advanced DirectX, so it's kinda hard to learn OpenGL or DirectX when you try.
When I've finished the Ruins Of Time engine, I'm gonna start dabbling in pure OpenGL and DirectX more.
Sounds like a good plan.
Theres an OpenGL Manual you cvan download somewhere from here:
http://www.opengl.org/When i started off with OpenGL, i found tutorials for certain things, but obviously i was limited to the types of things in the tutorials. Eventually, i found this manual, and started reading through all the commands to see exactly what i could do (though the real trick is in thinking inbetween commands).
OpenGL is like a big set of states, and you basically set the states that you want, and then it displays depending on those states.
Now, reading through this manual, there were many states which at the time, i couldn't understand the purpose of, or would ever have a reason to use (almost always will be many of them, though not hypothetically), but i just skipped them, and went overthem later, or learned some 3d theory, maths. If theres something you think it can do, then by repeating this kind of process while searching whatever tutorials you can, you can end up not quite needing as many tutorials. Or get a book
The following little tips aren't very complete: Some research is needed to get through all of them, they are just a direction:
For pixel perfect OpenGL, the first thing gluOrtho2D() or glOrtho() (gluOrtho2D calls glOrtho2D but with two default values for its last parameters).
Textures can't be mipmapped, as the filtering would destroy the pixel perfect requirement, so when creating a texture, you would be using glTexImage2D and not something like gluBuild2DMipmaps.
You would also need to disable texture filtering on that texture, using glTexParameteri. The parameters for GL_TEXTURE_MAG_FILTER and GL_TEXTURE_MIN_FILTER would both be GL_NEAREST: This says use the nearest pixel on the texture, rather than filtering the pixels with the surrounding ones (which looks smoother, less jagged, in 3d).
Its also good to clamp the textures to the edge, so for glTexParameteri again, GL_TEXTURE_WRAP_R/T/S can have the parameters passed GL_CLAMP_TO_EDGE.
If a texture is not of dimensions of power two (other conditions, see descriptions of glTexImage2D() ), it can't be displayed by the hardware, and so mipmapping must occur, so basically working only with images that are of that dimensional constraint is a requirement. Alternatively, you could have a spriite class which pastes the image loaded onto the nearest larger power of two size image, makes the texture from that, and then scissors a bounding rectangle when rendering the quad to which the texture is bound, such that the overhanging border region is 'scissored out'.
Now, In OpenGL, if you have a scene set up that should have a red pixel at an exact coordinate, such as 40, 30, that pixel will not actually be at 40, 30.
It will be at the exact coordinate 40,30, but thats actually at the middle point between four pixels: The pixel obviously can't be drawn between pixels, and is instead drawn in one of the four pixels that it is in; It draws/outputs the pixel that occupys most of the space of that pixel, and where several are equally present, takes them in a right hand order. If you draw a pixel at 0.5,0.5, then it is actually centered in the pixel. This doesnt cause too much of a problem, but the offset can clean a few impurities you might have during animation, rotation, etc.
In case it is enabled, disable dithering as well: glDisable(GL_DITHER); (.. i think)
And no depth testing, such that images are drawn in order of being sent through (disabled by default).
