It's easiest to start with 3D lines, as Phosphoer said you want a cloud of planes, but ideally you'd want to wrap them individually around the camera rather than as a whole else you'd notice sudden jumps in them(depending on they are laid out). So you have a cube of points, then a virtual cube that initially houses all these points, this virtual cube follows the camera. If a point leaves the cube then you wrap its position so it's now inside the cube again but on the other side(note: this isn't the same as repositioning it at the cube wall, as doing so would lead to a flat plane of points if you moved really fast).
Now you have a bunch of points(nothing more than vectors thus far), if you want them to extend based on your movement speed then you need to draw a line from this point to this point + velocity, where velocity is a 3D vector much like the point positions. This is great and all but if you want them to be planes then things get more fun, first of all you won't under any circumstances use a separate object for each point or particle in this cloud, doing so is heinously inefficient. Instead, you will make a single object and alter the vertex buffer yourself to simulate many separate planes.
If you're not sure how to do this then, excerpt:
// Create mesh
dbMakeObjectPlane( ID, 0.0f, 0.0f );
// Overwrite it with a new mesh
dbCreateMeshForObject( ID, FVF, vertCount, indexCount );
dbConvertObjectFVF( ID, FVF );
// Setup basic attributes
dbSetObjectRadius( ID, -1.0f );
Note: the radius is set to -1.0f to prevent culling issues and culling shouldn't even be required on such an object anyway.
Say you have 100 particle planes, you'd want 400 vertices and 600 indices and you'd then arrange your index buffer to form 100 quads: {0,1,2,0,2,3,...}.
Now, to make these planes rotate toward the camera so you can always see them you must first find the 2 vectors for each point mentioned above(particle point and point+velocity, now known as pointA and pointB or just A and B). Then find the centre of them( (A+B)*0.5 ) then subtract the camera position, this gives you the vector between the centre of your particle and the camera(now known as C). Now just
vector cross product this vector with your camera velocity(D = cross( C, velocity ) or cross( C, A-B )), this gives you a vector perpendicular to both the vectors between the camera and particle and the particle's direction(now known as D). You then write your 4 vertex positions where the first 2 are the points lying on the particle's position(A), you just set their positions to pointA + and - the perpendicular vector(D). Your last 2 vertices get the positions of pointB + and - the perpendicular vector(D).
I hope that made sense.