manual rotation?

[laochailan]

I didn't get it to run here, but what you do there to rotate your sprites seems a bit strange to me. Is there any reason you don't use OpenGL's capabilities for rotation/matrix manipulation? would be faster and easier (no need for a vector/matrix implemntation)

Just try something like:

glPushMatrix(); // gl's matrices work like a stack

// the order of these manipulations is important, by the way.

glTranslatef(x, y, 0); // translate to the position of your object (so now you are working relatively to that position) glRotatef(angle, 0, 0, 1); // the last three numbers are a vector for the rotation axis glScalef(texw/2.0, texh/2.0, 1); // mostly i also do this to make the following part clearer

glBegin(GL_QUADS); glVertex3f(-1,-1,0); glVertex3f(-1,1,0); glVertex3f(1, 1, 0); glVertex3f(1,-1,0); glEnd(); glPopMatrix(); // pop our modified matrix again

this way you can improve performance and simplicity. and matrix manipulation is a feature every implementation of opengl has. further hints for performance:

• as far as i know, a loop or any unnecessary stuff between glBegin() and glEnd() is harmful, avoid it.
• backface culling is a reasonable way of improving performance. in your current setup, also the back of all your surfaces is drawn, so you have twice the drawing costs. try glCullFace()
• normally you don't need the depth buffer in 2d, you you can disable the depth test. glDisable(GL_DEPTH_TEST)

i don't know if this is a help, i just felt like writing it when reading your code.

[lolitrain]

Thanks for looking at my small project I really appreciate it.

I am unsure whats the best way to implement rotation, so I implemented with manual matrix multiplication. The original Python code used PyOpenGL and worked the way you describe it. But it was way too slow and I had to switch to vertex buffer objects and shaders, but it was too slow anyway. The C rewrite of the code is the direct translation of the Python vertex buffer/shader code, minus the actual buffers and shaders :) (if that makes any sense). After rewriting everything in C the way you see it, the performance issues disappeared, so I left the code as is for now.

Depending on how things go performance wise later after I add more objects and effects, I'll most likely rewrite sprite rotation using vertex shaders so the manual matrix multiplication will be removed.

As to your other points:

• as far as i know, a loop or any unnecessary stuff between glBegin() and glEnd() is harmful, avoid it.
  • How will I draw all the objects without iterating through the vertices? (Vertex buffer objects, I'll get to them eventually)
• backface culling is a reasonable way of improving performance.
  • The only rotation I have so far is in the xy plane, so you never see the back face of any polygon any way.
• normally you don't need the depth buffer in 2d
  • Depth testing is disabled by default, and I don't think I ever enable it

[laochailan]

i don't think the manual matrix manipulation is faster at all. graphics cards can do that stuff way faster so the only thing you get is messy, less dynamical code. i do it the way i described in my project and i do it with really a lot of vertices every frame with blending enabled without having any performance problems (also with pretty old hardware). that's most probably not your bottleneck.

concerning the other points:

• you are allowed to iterate just try not to do it inside those macros. so iterate, grab four vertices, draw them glBegin(GL_QUAD); ... glEnd() and next cycle. it sounds strange but those things are somewhat sensitive to that.
• yes of course and that's where backface culling comes in. if it isn't enabled both faces are drawn. opengl identifies the "back faces" by vertex order. so clockwise or counter clockwise matters. you often see this method in professional games, for example when you glitch into some wall you are normally able to look outside and through the rest of the map. that's because only the front faces are drawn.

oh and i think relying on shaders for a simple thing like rotation is a bad idea. there are still some machines which don't support them.