#vector math

https://youtu.be/J7IKKzzApg8?si=04tTU-EeDF-A09mL

This is a zoom of a 41 iteration dragon curve. That's right 41 iterations. Why? Because i can :D Fun fact usually generating a dragon curve the memory requirement doubles each iteration, because you are copying and rotating the current curve. Double the segments, at best without any clever optimization its O(2^x)

So how hard is it to make say, 20 iterations? It was a long, long time ago, like 10 years, i followed an article that said you kind of have to write it in c so its more performant because 20 iterations on their machine took 20 minutes. 2^20 is going to be in the low one-millions range.

Now lets be more optimistic. Lets say computation time on a single cpu core has sped up 20 times, so you can generate a 20 iteration curve in 1 minute.

So 21 would take af least 2 minutes.

Now our scaling looks something more like 1m*2^(x-20). If we plug 21 more iterations to bring us up to 41, well we already know 2^20 is about one million, so this would be 2 million minutes or a bit under 2 years.

But guess what. This is rendering in real time. It would be incorrect to say that it generates the curve over 60 times per second, but it generates the visible part of the curve.

So what clever optimization trick gets me over a 120 million times speed boost at 41 iterations? Parallelization. See, this isnt just any dragon curve you see in c or java or python.

Vector

The cross product of vectors A and B is a vector perpendicular to A and B.

| i j k |

| 2 4 0 |

| 1 1 -1 |

= i(-4) - j(-2 - 0) + k(2 - 4) = -4i + 2j - 2k

To obtain a unit vector, divide by the magnitude.

Magnitude = √[ (-4)² + 2² + (-2)² ] = √(24) = 2√6

( -4i + 2j - 2k ) / 2√6 = ( -2i + j - k) / √6

OpenGL Mathematics

OpenGL Mathematics GLM has become the defacto standard for graphics vector math in C++ in the latest years. It's syntax mimics that of glsl so working with it while working with OpenGL, shaders... makes things easier cause the syntax is almost the same across the different languages.

openFrmaeworks, since version 0.10 uses GLM as it's default vector math library in the core and although old projects using ofVec* classes should work with minimal changes, if you are starting a new project we recomend to use GLM instead.

Namespace

GLM classes and functions are in the glm namespace so to use them you need to either prefix them with glm:::

glm::vec3 v(2.f, 2.f, 2.f); float l = glm::length(v);

Or in your .cpp files import the glm namespace at the very beginning:

using namespace glm;

And then use the classes and functions without prefix:

vec3 v(2.f, 2.f, 2.f); float l = length(v);

Functions not methods

GLM classes like vectors, matrices or quaternions don't have methods. Instead glm uses functions to operate on those classes so if you want to for example normalize a vector you would do:

glm::vec3 v(2.f, 2.f, 2.f); glm::vec3 n = glm::normalize(v);

The only exceptions to this rule are operators which you don't use directly but instead allow to do arithmetic operations so you can do things like:

glm::vec3 v1(1.f, 1.f, 1.f); glm::vec3 v2(2.f, 2.f, 2.f); glm::vec3 v3 = v1 + v2;

Warning

GLM vector have a static length function which returns the dimension of the vector type, so glm::vec2::length() returns 2, glm::vec3::length() returns 3...

Because C++ allows to call static methods on instances of that class you can make the error of calling:

glm::vec3 v(2.f, 2.f, 2.f); float length = v.length();

To try and get the length of the vector instead of the number of dimensions of the type. The correct way of doing that would be:

glm::vec3 v(2.f, 2.f, 2.f); float length = glm::length(v);

Mostly when porting old code form ofVec to glm, because ofVec included such a method, it's easy to try and call that function which will compile without errors but won't do what you expect.

When doing that, most modern compilers should show a warning because of calling a static method on an instance instead of a class, so be on the look for those when porting old code to GLM.

Type strictness

glm has a strict type system, similar to how things work in glsl, meaning that you can't autoconvert from one type to another automatically as it was the case with ofVectorMath.

For example:

glm::vec2 v2(2.f, 2.f); glm::vec3 v3 = v2;

Won't work anymore, you need to do now:

glm::vec3 v3 = glm::vec3(v2, 0.f);

Or in the oposite case:

glm::vec3 v3(2.f, 2.f, 2.f); glm::vec2 v2 = glm::vec2(v3)

or even:

glm::vec2 v2(v3)

Constants

GLM has some useful constants but the way to use them might be a little bit weird at first. The main problem comes from the fact that this constants are defined as templated functions so to call them you need to specify the type as in:

float p = glm::pi<float>(); double dp = glm::pi<double>();

Multiplication order

Finally, if you are used to the old openFrameworks vector math classes you would multiply vector and matrices like:

ofVec3 v; ofVec3f projected = v * model * view * projection;

with glm as in glsl the multiplication order is the oposite so now you would do:

so i made one up using the easiest thing to remember, the order of vectors.

start with i j k like this.

i   j   k

j

k

fill in the rest

i x j = k

j x k = i

k x i = j