eli5: why does ps1 games have wobbly vertices and stretched textures when viewing at an angle?
In: 6
So the most simple answer is that it comes down to the fact that the PS1 lacked proper hardware to calculate floating points. Instead, it drew it’s graphics using fixed integers. This works perfectly fine for static image generation, but when it comes time to draw graphics that have to adjust to things like player movement or camera angles, you get severe inconsistency in how these graphics are drawn on every frame. This leads to that trademark “wobble”, and general inaccuracies when applying textures to that geometry (on top of just a relatively small memory limit for textures)
So what is a floating point, and why does it matter? In the most basic sense, a floating point is simply a number that includes a decimal. If you remember basic math, you remember that decimals are used to represent a value between two whole numbers, leading to more accuracy depending on what you’re using those numbers for. And in the case of drawing graphics in a game, they help out a ton.
As the gaming space transitioned to 3d, developers encountered a problem with how to translate their graphical instruction to 3d images. And a big breakthrough in that came down to introducing floating points to draw their geometry. Floating points basically allowed developers to assign various points for the GPU to draw, and allowed the precision to update as the player perspective changed, keeping those points static, or adjusting as required with incredible accuracy.
At it’s most basic form, the CPU processes code and outputs points where things need to go. A wall needs to go here, the player model needs to be draw there, this needs to be ground, etc… Then passes that onto the GPU in order for the GPU to draw vertices outlining what the CPU has ordered, before painting them with textures to deliver the final product. Let’s say you want to create a wall, with four corners set at a specific point. If you’re standing in front of it, you can just have the GPU draw a wall with coordinates (X 27, Y 0) (X 27, Y 27), (X 50, Y 0), (X 50, Y 27) and it comes out to a rectangle on the screen. But what happens when the player moves two steps to the left? And then adjusts their camera 10 degrees to the right? and then walks 3 steps in another direction? and then backflips onto a platform that is drawn 50 units higher? Of course the GPU will draw this same wall in the same place in order to give the illusion of a static wall, but with just how varied movement and perspective can be in a 3D environment, you’re going to have to do it often, there are going to be a lot of variables that change how the wall is drawn in various ways, and you need to be as accurate as possible in order to really sell the illusion of the wall being a static wall. So floating points *really* come in handy to help create that.
But like we mentioned above, the PS1 couldn’t calculate floating points, and instead had to rely on fixed integers. Meaning that every time the GPU needed to update the points that make up that wall, it had to snap those coordinates to the nearest fixed location. So you move a specific distance in one direction and that wall has to update to reflect that. Then you move a different distance in a different direction, and you turn your camera, and move again, and so on. For each time the GPU has to redraw that wall, it has to find the nearest fixed number to move it to, and depending on how you move, it will adjust on every frame. Maybe it moves one point to the left, because you’re technically closer to that specific point on one frame, and then move so that you’re now closer to the point on the right as the GPU is redrawing that wall, leading to the texture “jumping” a few pixels in a direction as you continue to move back and forth.
And there we have it. Because the PS1 lacked the ability to calculate floating points (incredibly precise decimal values), it instead had to rely on calculating it’s graphics on fixed values. And as aspects of movement, including player movement and camera movement, continuously updated, the GPU had to find the nearest fixed point to draw graphics to, leading to notable inaccuracies that show up as texture and geometry wobble.
Latest Answers