I am experimenting with several ways to draw a lot of sprites (e.g. for particle system) and I have some inconclusive results. So this is what I tried and what I have:
This is done drawing 25k sprites:

1. Using regular `glBegin`/`glEnd` and using trig to calculate vertex points - 17-18fps.
2. Using regular `glBegin`/`glEnd`, but using `glRotate`, `glTranslate` and `glScale` to transform the sprite - 14-15fps.
3. Using vertex arrays instead of `glBegin` and `glEnd`, but still using trig to calculate vertex point position - 10-11fps.
4. Using vertex arrays instead of `glBegin` and `glEnd`, but using `glRotate`, `glTranslate` and `glScale` to transform the sprite - 10-11fps.

So my question is, why is using vertex arrays slower than using `glBegin`/`glEnd` while I have read (here even) that it should be faster?

And why does using your own trigonometry (which in my case is 5 cos, 5 sin, more than 5 divisions, 15 multiplications and about 10 additions/subtractions) is faster than using 5 functions (`glPushMatrix()`, `glTranslated()`, `glRotated()`, `glScaled()`, `glPopMatrix()`). I though they are done on the GPU so it should be much, much *faster*.

I do get more promising results when drawing less sprites. Like when I draw 10k sprites, then vertex arrays can be about 5fps faster, but still inconsistent. Also note than these fps can be increased overall because I have other calculations going on, so I am not really looking at the fps itself, but the difference between them. Like if vertex arrays and gl transform was 5-10fps more than `glBegin`/`glEnd` with manual trig, then I would be happy, but for now, it just doesn't seem to be worth the hassle. They would help with porting to GLES (as it doesn't have `glBegin`/`glEnd`), but I guess I will make a separate implementation for that.

So is there any way to speed this up without using geometry shaders? I don't really understand them (maybe some great tutorial?), and they could break compatibility with older hardware, so I want to squeeze all the juice I can without using shaders.