CODEWITHSUNDEEP
mathopengl3drotationorientation
kbirk
kbirk

Reputation: 4022

Fast and efficient way to store orientation in 3D space?

I originally stored an objects origin and orientation in 3D space using 3 vectors representing the objects origin, forward and up directions.

To apply to correct transformation to the modelview matrix stack I compose the affine transformation matrix using these three vectors.

Translation is trivial, however for rotation is applied by constructing the correct rotation matrix (depending on the angle and axis of rotation) and applying it to these 3 vectors.

I'm using this method for a very large number of objects and the rotation/ affine matrix composing is causing a performance bottleneck.

I'm wondering if there is a more sensible/efficient way to store the orientation?

Upvotes: 2

Views: 1973

Answers (4)

comingstorm
comingstorm

Reputation: 26097

A quaternion is probably the most natural/efficient way to store an orientation (it should be better in all respects than forward/up vectors). A quaternion will take 4 values to store, and takes 10 multiplications and 15 additions to convert to a 3x3 rotation matrix -- no divisions or transcendental functions are required.

If you are especially pressed for space, you can probably get by with only 3 values, as you can generate the first element of a unit quaternion robustly from the remaining three. This will take an additional 3 multiplications, 3 additions, and a square root (it is also slightly tricky, since you need to make sure this first element is nonnegative...)

Upvotes: 4

Arpegius
Arpegius

Reputation: 5887

Quaternions transformations may be faster then Matrix on current GPGPUs where the access for global memory is much slower then to local memory. According to this tables you compute twice much but need to fetch less then half of memory.

Rendering have the vertex shader uniforms stored as local memory, the only reasonable here is the use of matrices.

Upvotes: 1

datenwolf
datenwolf

Reputation: 162164

I originally stored an objects origin and orientation in 3D space using 3 vectors representing the objects origin, forward and up directions.

Or in other words: You're storing a 3×3 matrix. The matrices OpenGL use are just the same, though they're 4×4, but the only difference to your is, that the element 4,4 is always 1, the elements 0...3,4 are all 0, and the first column 0,0...3 is the cross product of forward and up, usually called right.

This is actually the most concise and directly accessible way to represent an objects placement in 3D space. You can apply any kind of transformation, by performing a single matrix multiplication then.

Another method is using a quaternion together with an offset vector. But quaternions must be turned into a matrix if you want your objects to be translatable (or you could chain up a lot of translation/rotation pairings for a transformation hierachy, but using a matrix actually causes less overhead).

Upvotes: 7

Alnitak
Alnitak

Reputation: 339816

Other than memory, what's stopping you from storing the whole 4x4 affine matrix?

Better yet, ISTR that if the array is normalised the bottom row is usually [0, 0, 0, 1] so you only need to store the top three rows.

Upvotes: 4

Related Questions