Basically, stop rotating it! :)

Get the transform matrix of your camera:

X = [ a b c 0 ]

Y = [ d e f 0 ]

Z = [ g h i 0 ]

The camera *looks* down Z, and the X/Y axes are left/right and up/down respectively. Given the width & height of your quad, you can compute the points directly:

P0 = X * (width/2) + Y * (height/2)

P1 = -X * (width/2) + Y * (height/2)

P2 = -X * (width/2) - Y * (height/2)

P3 = X * (width/2) - Y * (height/2)

Thanks Rob.

I found a solution within the library, after learning some basic math.

 Orientation3D.SetUpDirection(ref cparticle.Orientation, Vector3.Cross(cparticle.Velocity, CameraPosition - cparticle.Position));

I'll try to see if I can use your method to edit the vertices directly, but it looks a little like the function it calls is doing as you suggest anyway.

        public static Quaternion GetRotationTo(Vector3 CurrentDirection, Vector3 DesiredDirection, Vector3 sFallbackAxis)
        {
            Quaternion quaternion = new Quaternion();
            Vector3 vector = CurrentDirection;
            Vector3 vector2 = DesiredDirection;
            vector.Normalize();
            vector2.Normalize();
            float num = Vector3.Dot(vector, vector2);
            if (num >= 1f)
            {
                return Quaternion.Identity;
            }
            if (num <= -0.999999f)
            {
                if (sFallbackAxis != Vector3.Zero)
                {
                    sFallbackAxis.Normalize();
                    return Quaternion.CreateFromAxisAngle(sFallbackAxis, 3.141593f);
                }
                Vector3 axis = Vector3.Cross(Vector3.UnitX, vector);
                if (axis.LengthSquared() < 0.999998f)
                {
                    axis = Vector3.Cross(Vector3.UnitY, vector);
                }
                axis.Normalize();
                return Quaternion.CreateFromAxisAngle(axis, 3.141593f);
            }
            Vector3 vector4 = Vector3.Cross(vector, vector2);
            double num2 = Math.Sqrt((double) ((1f + num) * 2f));
            double num3 = 1.0 / num2;
            quaternion.X = (float) (vector4.X * num3);
            quaternion.Y = (float) (vector4.Y * num3);
            quaternion.Z = (float) (vector4.Z * num3);
            quaternion.W = (float) (num2 * 0.5);
            quaternion.Normalize();
            return quaternion;
        }

Your method seems way simpler :)