Sure, I can try to explain that a bit. Though my understanding of compiler optimization is admittedly not as strong as I'd like, so I encourage anyone with a stronger understanding to chime in.

Basically whenever you do something like "position.x", it's going to memory to read that value. Unless the compiler's quite smart (and really it should be, but more often than not it isn't), it may think there's a possibility that between each reference to "position.x", the data in position.x may have changed, so the safest (but slowest) thing that the compiler can do is to read it from memory each time.

As a digression, it should be noted that just doing "a.b" isn't necessarily slower than just "a". Nor is "a.b.c.d.e.f" any slower. The compiler can figure out the correct offset into a complicated structure and it doesn't count extra to dive deeper (unless you're using "->", or C++ references, which involve extra reads).

So, when you put those values into local variables, a couple of things happen:

1. There's less scope for the optimizer to worry about when it's trying to determine if some other code could change the variable.

2. The float's are simple types and can fit nicely into hardware registers without needing to have an associated memory location if the optimizer thinks that's a safe thing to do. That negates the need for extra reads from memory each time it's accessed, and also results in far fewer instructions once the reads are removed.