Differences between Tesla and a GeForce Series GPU

Tesla (and all Quadro) chips are much more
focused on the floating point
side of things than Geforce cards are. FP calculations in game aren't generally that excessive (in the scheme of things) and so
it's suitable to run them on the CPU.

Moving to the workstation, let's setup an example. Let's assume you're dealing with creating a 3D model. If you're making your first game,
your models will probably be low quality and have a low polygon count. You build them as low quality. If you're building a triple-A title, you'll be looking to build extremely high quality models. You might have a model with 1M polygons and a lot of animations.
Almost all of this data will be stored as floating point values (e.g. length of each edge, angle of connecting polygons, etc). In order for this to run on consumer systems, you'd want to optimize it. I believe this can automatically be done by some model creation
programs, but in order to do so, it's got to do a lot of calculations about which part of the model can be rendered in the texture (e.g. creases in clothing) and which need to be part of the model (e.g. a characters limbs). The end result might be a model
with 50000 polygons, and much of the detail has been baked into the textures.

In order to store the data for that 1M polygon model, you need a lot of VRAM. When you're creating a world, you might be dealing with many millions of polygons, you need massive amounts of VRAM. This is why workstation cards generally have more VRAM. There's
also optimizations underneath specifically designed to dealing with FP calculations.

To put it in perspective, a Geforce card might have 80% of it's FP processing units disabled, while a Quadro would have them all enabled. This is done for the sake of power usage (and thus heat output and thus noise). Gaming systems don't generally do massive
FP calculations on the GPU. Sure, they might have PhysX but that doesn't take anywhere nearly as much power as you'd expect. Bitcoin mining is one abstract case where having better FP performance on the GPU is highly beneficial, but by having a majority of
the FP units disabled, you can provide the rendering units with more power, which is handy if you want to fit more transistors/use a larger die, without increasing the TDP output or the overall power draw of the card.

In order to calculate
FP on a GPU though, your application needs to have support for the relevant API (e.g. OpenCL, CUDA, etc) and routines to process and handle the data you're feeding and getting back.

TLDR:
Quadro/Tesla for calculation, Geforce for rendering/consumers.