Float, double or both for 2D Vector class?

Question

I'm currently writing a small cross-platform OpenGL-based 2D game engine for our studio. When I researched which 2D Vector class to use, I stumbled across three different design paradigms:

• Float & Call-by-value, like in this Gamasutra article. Seems to be fast but offers little precision (see also this Thread). Pro: Fast, portable and compatible with most libraries.

• Double & Call-by-reference. If I understand the above article right, I could also use 2 double precision variables instead of the 4 float numbers. According to the above thread double's still slower than float.

• Template for double and float: The widely popular book "Game Engine Architecture" uses templates to make it possible to use float and double as needed. The obvious downside is code bloat. Also, I doubt it that the code can be optimized without basically writing two classes, anyway.

I would appreciate to learn what solutions you're using in your in-house engines and how precise e.g. popular game engines are, so I can decide what solution I'll implement in our engine. In the moment I'm thinking about simply using float precision and live with it.

Answer 1

I always use float unless I have a reason to use double, much as I use int unless I have a reason to use int64_t.

Floats have no problem doing precise integer arithmetic up to 2²⁴, which is what most people are (mostly irrationally) afraid of. Doubles do not solve the problem of common values being unrepresentable exactly - whether you get 0.10000001 or 0.10000000000000001, you still must make sure your code considers it "equal" to 0.09999999.

Doubles are slower on every platform you'll care about writing games, take twice the memory bandwidth, and have fewer specialized CPU instructions available.

Single-precision floats remain the standard for hardware graphics interfaces, both on the C/C++ side and inside shaders.

You'll probably need a double vector at some point, but it should be used when needed, not by default.

As for templating - you're right, for maximum performance you'll want to specialize the templates manually anyway. Aside from that, I ran some tests for some templated code over the weekend (making a 4-ple IntRect and FloatRect), and found that the templated version took about 20x longer to compile than just repeating the code, which amounted to about 15 lines. Repetition sucks, but waiting for compiles sucks more - and it's not like I'm ever going to need a StringRect or FooRect.

Answer 2

The Microsoft XNA game framework has a Vector2 class which uses floats. This would be my personal biggest reason for going with floats, as I trust the wisdom and experience of the XNA team to be much greater than my own.

I found it rather interesting to read the answer in this Stack Overflow question: "Float vs Double Performance". There is also a gamedev.net thread with some discussion of double performance in GPUs. I think it's safe to assume that doubles are slower than floats, at least in many GPUs, and I personally always used the float OpenGL functions over their double counterparts. This may not apply nowadays, but if you consider that not everyone who runs your game has the latest GPU with native double support, I think this is reason enough to use floats and gain that extra bit of performance.