love your style. I've got a request for you!!! could it be possible to discuss establishing and handling a homography matrix and the fundamental matrix transformations in regards to visual SLAM and or AR applications (in javascript? heehee)

Great explaination..!!! Can you please make a video on rotating vectors in 3D?

So, is this essentially what 'Unrotate Vector' does in Unreal? I know you can use it to re-orient the characters velocity in terms of its movement rather then it's movement in the world. It takes in a Vector and a Rotation. The Velocity would be the vector and the characters world rotation would be the Rotation in that example. the result would be x = -600 if your strafing left or x = 600 if you're strafing right....same for forward and backward except on the 'Y'. In Unreal it just says 'Returns result of Vector A rotated by the inverse of Rotator B' where A is the input vector and B is the input Rotator

what about quaternions could you explaine them the same way

I've been wanting to do that! though as proper edited video rather than a quick recording :)

Hmm, I don't know about quaternions. I know this topic with matrices and the rotation axis vector. In the video case, is when the rotation vector is (0,0,1). Then in other direction on 3d space, just use another vector. Quaternions are much different? Looking forward to see the differences of approaches.

A nice exercise is to write down a 2D rotation using quaternions (rotate about z say) and show how it relates to rotation using complex numbers and then (via de moivre’s theorem) to the use of matrices shown here.

@@acegikmo Yes, same way with quats!

@@acegikmo rather than quaternions, try to do about geometric/clifford algebra. that has properties which are superset of quaternions. and geometric/clifford algebra will attract audience from new physics/science background as well, not just old physics/animators. 3:36 yeah, clifford algebra is essentially a different way to write quaternions, but with one suprisingly simple twist which makes it ever more powerful than quaternions.

I love that I had never thought that by rotating the coordinate space you would gain a cache of the expensive trig functions so that you cold apply the same to a bajillion vertices quickly. Super clever.

@@frollard Yes, that's why we use matrices all over the place. Your GPU is even optimised to do matrix and vector multiplications. The great thing is that you can combine multiple transformations into a single matrix and with a single matrix multiplication you can effectively apply several transformations at once. In computergraphics we usually use 4x4 matrices. So we extend our 3d space into a what is called homogeneous space. We simply offset out 3d space from the origin into the 4th dimension by one unit. This allows us to represent translation transformation with a matrix which are usually not possible. While it is a bit difficult to envision a 4d homogeneous space, the same thing can be done for 2d space where it's easier to understand, but the concept is the same. So imagine a 2d space that is offset from the origin by 1 unit in the z direction. When looking at the space along the z direction, you don't see the offset since we have a 2d space and everything is projected orthogonally onto the normal 2d space. However what we can do now is applying a shearing transformation in 3d space which has the effect of moving the homogeneous space around. The third column in our matrix would simply be the offset of our origin. That's because position vectors are now also 3d vectors where the z component is always "1". So when applying the matrix to a vector, the 1 is multiplied by that 3rd column which is simply added to the result and causes an offset. As I mentioned, the same works in higher dimensions and is what we're using in usual 3d graphics. The usual graphics pipeline of most game engines define the points / vertices of a certain object in local space. An object has a local2world matrix (often called model-matrix) which brings the local space vertices into worldspace. We usually place a camera in the scene which is responsible for actually defining where the view should be positioned in the virtual world. What we do here actually is using the inverse matrix of the camera object (this matrix is usually called view matrix). So we transforming all the worldspace positions into the local space of the camera. Depending on the kind of camera we also want to apply some kind of projection from the 3d space of the camera to the 2d space of the screen (either orthographic or perspective projections). For this the camera has another matrix which is called the projection matrix. There are some other transformations after that to actually get to screen space, but this is usually done by the GPU itself. The neat thing is the combination of view and projection matrix can be calculated once per rendered frame as it does not change during one frame. For each object that is rendered, we simply combine the model matrix with the already combined "VP" matrix to form the MVP matrix for this object. Now all we have to do is grab all vertices of the object (which are defined in object space) and multiply it by this single combined matrix and as a result we get the positions of the vertices on the projected screen. That, in a very simplified manner, is how a computer renders a 3d scene. Technically speaking you could say that the camera doesn't really move through the world, since that would is purely virtual. In fact when you move the camera around, the whole world is actually rotating around the fix camera. This is pure relativity at play ^^. From the view of the computer screen it's not the camera or the screen that moves, but the whole virtual world is moved. I can highly recommend the Linear Algebra series of 3b1b. He also goes into quite some details about the vector / point duality and that the term transformation and the term point can actually be interpreted as the same thing.

most of my recent videos like the bézier video takes a very long time to make unfortunately! but I'm working on it, the next proper video will be on splines, which is turning out to take much longer than I was hoping, haha

I suggest taking an introductory course to linear algebra at some university. There are most definitely many video lectures available online nowadays. Taking such a course personally helped me understand how to interpret matrices in general and how to make them do what I need to.

​@@stewartzayat7526 Oh I already have. It didn't help much for making matrices more intuitive to me, sadly. But I'm glad to hear those have been helpful to you!

Wish the names sine and cosine were flipped so it were more intuitive to x/y. Copilot, coproducer etc are all the secondary, where on grids you generally derive y from x, making x the primary. Would also make more sense with "sin cos tan" being in the order of xyz. Maybe I'm just too smoothbrain tho

I've considered this! it might happen after the spline video is done :)

Quaternions are probably best thought of as the composition of two reflections. The quaternion reflection formula isn't as well known as rotation, but it's still very simple and can be derived from the quaternion product and the projection operator, and you can use ordinary euclidean geometry (no vectors needed) to derive the relation between rotation and reflection. Ok, technically _rotations regardless of dimension_ can be thought of as the composition of two reflections. If you have some way to easily represent reflections and compose them, them you can easily do rotations in any kind of space. Do keep in mind though that double reflections generally rotate by _twice_ the angle between the two mirrors. Wait... _twice?_ Don't quaternions have a weird property where you need to use half the angle and then multiply from both sides? Could it be that this double reflection concept has been baked into quaternions from the start‽

> ... the swap of sin and cos isn't some hacky black magic but actually a property of these functions... Thank-you for this.

Thanks

in that case it emerges from how vector*scalar multiplication works, it effectively transforms it to that frame of reference, since those vectors are orthonormal

photoshop

yep! though it can be interpreted both as the local space components of the constructed coordinate system during conversion, but it's also the world space coordinates of the position before rotation

Wouldn't V, Vx, Vy be the coordinates in global world space before rotation? And Vectors a,b be the new basis for a new local space. And V',V'x, V'y be the new coordinates of a point with rotated axes in global space. If V is in a local space whose axes have been rotated theta, then the rotation operation would convert that to global space.

@@matthewpublikum3114 well, yes, exactly!

you usually use both quaternions and matrices in games! quaternions for manipulating and compositing rotations, matrices for space transformation

Notion, as of late, before that, sublime text

yeah, in 3D space it gets more complicated because there are more degrees of freedom, and not just one plane of rotation. in game engines, you usually supply the normals and the tangents to calculate tangent space, the bitangent being the (somewhat) unique unit vector perpendicular to both

Through addition, in the video she shows this formula v = v.x * a + v.y * b

@@abdurrahmanalyajouri7992 Oh, thanks!

this is for any space. in 3D it gets a little more complicated, but it's not too different, they both usually use matrices

oh that's super neat!

I'm sure you already know this, but for anyone else wondering why this is: It's because e^(ix) represents a circular motion in the complex plane. It traces out a circle as x increases. The derivative is like the velocity of the point as it goes around the circle, so it's always tangent to the circle. And (remembering our geometry) the tangent of a point on circle is always perpendicular to the radius at that point, hence the vector pointing at e^(ix) will always be perpendicular to it's derivative. That "swap and negate" pattern is characteristic of perpendicularity.

nope! but my Mathfs library does :) github.com/FreyaHolmer/Mathfs/blob/34b0332d9d14ad4ba34d88a482a03fc63ca4110c/Mathfs.cs#L931-L934