I always forget or mix up how to extract variables from a formula when division is involved, which always slows me down as I have to sit with pen and paper to get it straight. So lets just get it straight and simple here, so I can look it up whenever I need it!
(Note: the one furthest down is the interesting one. Not even sure why I have addition in there, but I let it stay.)
Warning: lengthy post ahead! But lots of really cool stuff!
Been a while since I posted now. There are a couple of reasons for this:
But now I finally have something to show, so lets show it!
READ MORE >>Up to this point I’ve only drawn wireframes. To create colored 3d objects I need two things. Backface Culling and Z Sorting. Time to start with the first: Backface Culling.
Now you no longer see any lines “behind” the cubes. I also draw the normal vectors for each triangle.
From this point I just filled the triangles with a single color.
With the normal vectors already calculated on each triangle, I tried to implement some directional lighting as well. It went much smoother than I would ever have thought.
Pretty interesting! I made a spinning cube with lighting almost exactly ten years ago. However I did not understand much of it, and going back to that tutorial it seems to be full of weird tricks. This time however I did it all by myself =D.
Next up is Z-Sorting so we can have more than just one cube at once
I’m doing serious progress! Today I managed to get the camera matrix working!
The coolest thing about this is that just a few months ago I would have thought that this was too much math for me to ever be able to understand! Remember that I have written everything from scratch - except for the line render code, which is basically just a lineTo(x,y) function. Even the matrix implementation.
There’s no frustum culling in there yet (except for any z-values behind the camera) so pretty much everything gets drawn all the time.
Resources for camera matrix: Camera View Transform Matrix Faster Matrix Inversions
In our last blog post we used matrices to translate, rotate and scale vectors, but so far only in 2D.
Transforming vectors in 3D is pretty much the same thing. The only difference is that we cannot directly plot those vectors out on the screen since each vector will come in a triplet of {x,y,z} and the screen only consists of {x,y}.
We could just ignore the Z-coordinate, but that would look weird!
To get it to look right we need to apply perspective. Perspective means that an object that is further away from our eye will appear smaller than an object that is closer!
Applying perspective to 3D-points is something I’ve been able to do for a long time, but now we’re working with matrices, and of course there is something called a perspective projection matrix!
Another great resource I found on the subject is scratchpixel.com, here on Perspective Matrix Projection.
In the past when I’ve been playing with 3D, I’ve used trigonometry for all transformations. It works, but has several drawbacks!
Using matrices is superior by far. The image below is just a couple of matrices combined, using vectors forming a cube and a pyramid. This would not have been possible using my old 2006 methods!
If you want to read up on this too, then check out:
Math for game developers youtube channel And http://www.scratchapixel.com/index.php?nocategory
After my Shader Week I decided to try to re-wake the math part of my brain that feels like it has numbed of a bit in recent years of Android app development. I have actually been doing this for several weeks now, but have not had anything to show until now.
So I started reading up on Linear Algebra, and is currently writing my own custom implementation of Vector and Matrix-classes from scratch in Haxe. And it’s super interesting!
If you have a 2x2 matrix you can put an up-vector in the first column and a right-vector in the second column. When multiplying a vector with this rotation-matrix it will transform the vector into that coordinate space! If you rotate the up and right-vector clockwise each frame you get a rotation matrix!
In this first image I multiply four 2d-vectors through a rotation matrix. The unmodified vectors are shown to the left.
Another interesting thing with matrices is that you can combine them! If you have one matrix for translation, one for rotation and one matrix for scaling, you can get a single matrix containing all those values by multiplying them! Just remember to multiply them in the correct order!
If you have a TRS-matrix named M1, and another TRS-matrix named M2, you can move the transformation of M2 into the local coordinate space of M1 by multiplying M2 with M1! By doing this M2 will be “parented” to M1! It’s so simple!
The big square is rotating and the second, smaller square is parented to the big one, therefore inheriting its rotation. Same with the third square (it inherits both the rotation and scale of it’s parent before applying its own rotation).
The vectors (points) for all three squares are just a single unmodified array. All the transformations are done though a single matrix multiplication (for each point).
I will keep working through the math, so expect more posts on this. In the mean time, these two youtube playlists are really great resources: