Sign up ×
Game Development Stack Exchange is a question and answer site for professional and independent game developers. It's 100% free, no registration required.

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.

share|improve this question
Slower where? You can't talk about speed if that's not tied to a particular architecture. –  o0'. Oct 1 '10 at 9:33
@Lo'oris: I don't know any architecture where double is faster than float. –  user744 Oct 1 '10 at 11:06
Rather than writing your own vector class, consider using Sony's (…). It is an easy drop-in header-only "library" that has already been micro-optimized, and all vector libraries are basically the same external interface anyway. –  user744 Oct 1 '10 at 11:32
@Joe: 2 doubles instead of 4 floats? –  o0'. Oct 1 '10 at 11:41
@Lo'oris: The question is worded a little weird, I don't know if the questioner is confused or just you - you use two doubles "instead of" four floats when dealing with SIMD, because the register is 128 bits wide. You still need to process an equal number of numbers, and you're doing it at half-speed. –  user744 Oct 1 '10 at 12:00

2 Answers 2

up vote 7 down vote accepted

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 224, 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.

share|improve this answer

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 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.

share|improve this answer
From the SO question: "On x86 processors, at least, float and double will each be converted to a 10-byte real by the FPU for processing." While this is true, it neglects both SIMD instructions and the additional memory (= worse cache coherency, more memory bandwidth) requirements of doubles, both of which continue to make it slower than float in real-world tests. –  user744 Oct 1 '10 at 12:02
I figured there was a catch. You should comment that onto the SO answer, I'd upvote it. –  Ricket Oct 1 '10 at 16:23
It is already there as a comment. –  user744 Oct 1 '10 at 16:38
Since you brought up XNA, I may as well point out that Direct2D also uses single-precision floats. –  Mike Strobel Oct 1 '10 at 19:23
And for completeness, OpenGL has float and double versions of its methods, so it's neutral in this sense. –  Ricket Oct 2 '10 at 22:24

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.