In games, we often work with a variety of coordinate spaces. Geometry is defined in model-space. Different objects don't have to share the same model space. Coordinates are then converted to world-space using a transformation matrix. Usually this is just a combination of translation and/or rotation matrices, but can also include things like scaling, or even non-affine transformations.
Usually everything in the scene is considered to exist in the same Cartesian world-space. Another transformation is then used, called the view transform representing the position and orientation of the camera. This results in eye-space (also known as camera space), a Cartesian space where the Z axis represents the direction the camera is "looking".
Up until now, we haven't taken into account the nature of the camera or eye's lens. Cameras generally attempt to image the world in the same way as the human eye, using something called rectilinear perspective projection. We use another matrix for this step, called the projection transform. Now, a perspective projection can't be implemented entirely using only a 4x4 tranformation matrix. We also need another step, called the perspective divide where we divide the X, Y, and Z coordinates by W to make distant objects smaller. This gives us what we call normalized device coordinates (NDC) which are usually multiplied with the width and height of our canvas to yield screen-space (technically this is called the viewport transform).
On top of all this, in games we have other things to worry about. Normals may need to be transformed differently than points and tangents, and we often need to be able to reverse all of the above operations, for instance, to know what the player clicks on. The list could go on, but none of that sounds like it is applicable to your situation.
If you want it to look like you're inside a sphere looking at it's inside surface*, the model transform converts from spherical to Cartesian world coordinates (You can't actually do this with a transformation matrix, but the formulas are availble here). The view transform rotates the camera, and the the projection transform handles the perspective calculations. The latter two can be combined into a single 4x4 matrix. Then you just multiply that matrix by each vertex after converting to Cartesian coordinates - but don't forget the perspective divide and viewport calculation!
*In this case, this is known as a Gnomonic projection. (Thanks DMGregory!)