Game Programming Gems I has some information. You might want to find a
book specifically on quaternions, too.
Depending on your objective, you might be able to get away with
something simpler. If your trying to rotate around a fixed point where
the particle animation is (say, like the camera being a satellite and
the satellite orbiting around the world), you can create your own
model-view matrix transformation that will rotate around for you. Of
course, your not rotating around the world, your rotating around a
particle animation.
For example, translating by -N (where N = radius out from origin) out
and then rotating by X, Y, and Z axises respectively will have the
camera rotate about the origin.
i…e (From redbook)
void polarView{GLdouble distance, GLdouble twist,
GLdouble elevation, GLdouble azimuth)
{
glTranslated(0.0, 0.0, -distance);
glRotated(-twist, 0.0, 0.0, 1.0);
glRotated(-elevation, 1.0, 0.0, 0.0);
glRotated(azimuth, 0.0, 0.0, 1.0);
}
You do this translation before the modeling calls (i.e. drawing the
particle calls)
To find N (distance) programatically, it might be a little trickier.
However, if you find the bounding box of the scene, and the distance
from the center of that bounding box to one of the points, that will
give you the radius of the bounding sphere of your scene. Now, imagine
a bounding sphere around the scene. Draw this on paper. Take your
camera, extend it out, and draw two lines from the camera to the
bounding sphere until it looks like an ice cream cone. The center of
the bounding sphere to the camera is distance d. You know your field
of view, it is whatever you desire. Now, imagine a cutting plane in
the middle of the sphere, say in-between the near plane and far plane.
The extent (height) of that is twice the radius of the bounding
sphere. You can then use trig to find the distance from the camera to
the center. That should be your N. Then, knowing the radius of the
sphere, with similar triangles and knowing the distance and size of
the middle plane, you can find the near plane and far plane by
observing the near plane is distance (d - r) and the far plane is
distance (d + r), thus creating a nice tightly bound frustum for use
with gluPerspective, for use with your perspective transformation.
Note: I haven’t tried this 
I’m still new to this field. I hope it helps.-----
Matt Johnson
Graphics Developer
VCom3D, Inc.
I’m writing a particle system for my final year project at University and to
verify that my particles are being processed correctly I’m wanting to use a
quaternion camera to rotate around the particle system.
The thing is, as I’m making my particle system a library for others to use
the camera is only for my own demonstration purposes and, as such, I don’t
want to spend a lot of research time on quaternion cameras when my
dissertation is largely based on other things =o)
My question is; Is there a decent book or tutorial which has a quick guide
to making a quaternion camera?
Currently, I have an OpenGL and SDL app which implements my particle system
library and, ideally, all I want is to be able to move the mouse and have it
rotate around a point at a specified distance.
I have found various articles that mention quaternion cameras but they all
use the mathematical functions of DirectX and as I’m writing my particle
system to be cross-platform this isn’t exactly ideal.
SDL mailing list
SDL at libsdl.org
http://www.libsdl.org/mailman/listinfo/sdl
–