Basically you need to define a origin point that your camera will rotate around.
Now your camera's position will orbit this point. So you will still need to move this point around in the world.
You will make some extra values that go thru steps to orbit that position around that point of rotational origin.
You will make a rotational matrix which will describe a rotation that will have a directional axis, the rotation will orbit circularly around that axis on a perpendicular plane that is orthagonal to that direction vector.
The orbital position itself will be defined by 360 degrees of rotation, on that plane, around the directional vector you designate.
You will simply define a direction the camera is to look towards.
You will normalize that (well it depends).
You will either use it directly in create world () or create look at ()
Or you will add the current cameras position to that calculated normal in create world() or create look at().
Edit added a distance from origin vector to rotate by forgot that.
// These variables control the orbital camera.
Vector3 cameraPositionOriginOfRotation = new Vector3(125, 43, 200f);
Vector3 cameraTarget = new Vector3(0, 0, -10000f); // a world position the camera will look towards
Vector3 cameraDistanceFromOrigin = new Vector3(0,0, 50); // the 50 is actually a distance.
Vector3 cameraOriginAxisVector = Vector3.Up; // if you make your own direction normalize it.
float cameraOrbitInDegrees = 15f; // now you loop this from 0 to 360 to orbit
float ToRadians = (float)(Math.PI *2d / 360f); // 1 360th rads
float rotationInRadians = cameraOrbitInDegrees * ToRadians; // degrees to radians
// rotate the camera around some positional axis could be almost any vector3 that has been normalized()
// typically you pick a axis by Vector3.Normalize(cameraTarget - cameraPosition);
Matrix m = Matrix.CreateFromAxisAngle(cameraOriginAxisVector, rotationInRadians);
Vector3 newCameraPosition = Vector3.Transform(cameraDistanceFromOrigin, m);
newCameraPosition += cameraPositionOriginOfRotation;
// typically you want a target for the view matrix.
Matrix cameraWorldMatrix = Matrix.CreateWorld(newCameraPosition, Vector3.Normalize(cameraTarget - newCameraPosition), Vector3.Up);
Matrix cameraViewMatrix = Matrix.CreateLookAt(newCameraPosition, cameraTarget + newCameraPosition, Vector3.Up);
// However to do as you describe just send in the target as a straight up normalize direction.
Vector3 cameraFaceForward = new Vector3(0f, 0f, -1000); // this is not a target its a cameraLookAtDirection
Matrix cameraWorldMatrix_PerTheQuestion = Matrix.CreateWorld(newCameraPosition, Vector3.Normalize(cameraFaceForward) , Vector3.Up);
Matrix cameraViewMatrix_PerTheQuestion = Matrix.CreateLookAt(newCameraPosition, cameraFaceForward + newCameraPosition, Vector3.Up);
Those are the basic steps.
The code also offers a slight alternative to doing it as you described by setting a target that is not locked to a specific direction but could instead be a far off position as some look at target position in the distance.
This is not tested code i just wrote it straight out (though i wrote it to work).
Here is the matrix class create look at and create world are within.
So you can see what is initially done with the variables you pass.
The functions do normalize the forward and the (position - target) you pass so be aware of that.