Exploring the Android OpenGL projection matrix in depth of "rooting at the foot"

The world is changing really fast, the previous period of time Windows development technology hot still in full swing, web technology began menacing, just as the web presents a thriving, Android small robot, bite the apple, Winphone development platform and lightning-like cut the chaotic web world.

I believe many developers are wondering why the world is not around me. But I'm around the world turning. My answer is that the Shaolin monks learn to fight, the first to learn to stand pile. To practise, occupy three years first. The Shaolin monk fights never revolve around others, but others revolve around him.

The principle of the world is the same, developers like to do the foot rooting.

Looking at OpenGL's projection matrix in recent days, I've also implemented a projection matrix:

"1 0 0 0"

"0 1 0 0"

"0 0 1 1/d]

[0 0 0 0]

where D stands for the near-plane distance.

Do anything, must take the question to study, this is my principle, otherwise do not learn, do not believe the book is better than no book, is understand not understand better than do not understand. My question is why the projection matrix of OpenGL is so complicated, I think the complexity must have its complicated reason. After some research, the fundamental reason is to map the real body to a cube, the range is " -1,1" side length of 2 cubes. Instead of switching directly to the screen. This is the idea of OpenGL. So it's not right to switch directly to the screen like I did. X, y passes through this transformation to -1,1. The transformation of z must satisfy the rules of linear transformation. The process of derivation is not complicated. The principle is that x, Y is compressed in linear proportions. The z-axis is a linear transformation to meet the requirements of the linear matrix. These derivation is very simple, do not say.

The next thing to say is even more surprising, since the study of the underlying implementation of the UI cannot be limited to OpenGL alone. So I went back to anatomy the Skia library. The Skia library on 3D can be said to be a piece of cake in front of OpenGL. But in 2D graphics processing, it can be said that OpenGL is a piece of cake. They are therefore complementary to each other. Of course, my research is Skia also added some 2D graphics for 3D effects. Some of these matrix transformations. It just confirms how correct my matrix is. Refer to the SkCamera.cpp file for details. The specific inside of those mathematical matrix operations how to do not say. The underlying principle is the projection matrix I mentioned above.

These things are very simple. Isn't it?

Specific OpenGL is how to calculate, a little bit of linear algebra knowledge of people, advanced algebra, etc. can be understood, the following is the link.

http://hi.baidu.com/dych_cnu/item/a7b78ba58a86e0208819d30f

Java code

2. void Skcamera3d::p atchtomatrix (const skpatch3d& Quilt, skmatrix* matrix) Const {
4. if (fneedtoupdate) {
6. this->doupdate ();
8. Fneedtoupdate = false;
10. }
14. const skscalar* MAPPTR = (const skscalar*) (const void*) &fOrientation;
16. Const skscalar* PATCHPTR;
18. Skpoint3d diff;
20. Skscalar dot;
24. diff.fx = quilt.forigin.fx-flocation.fx;
26. Diff.fy = Quilt.forigin.fy-flocation.fy;
28. DIFF.FZ = QUILT.FORIGIN.FZ-FLOCATION.FZ;
32. Dot = Skunit3d::D ot (* (const skunit3d*) (const void*) &diff,
34. * (const skunit3d*) ((constskscalar*) (const void*) &forientation) + 6);
38. //The structure of the patchptr is {u,v,origin} where the u,v represents the column vector
40. //Origin is the origin of the coordinates.
44. PATCHPTR = (const skscalar*) &quilt;
48. /* 
50. where matrix represents a 3x3 matrix
52. The first line represents the coefficient of U, the second row is the coefficient of V, the third line is the coefficient of diff
54. Each column in the matrix represents an axis.
56. */
58. //First column
60. Matrix->set (Skmatrix::kmscalex, Skscalardotdiv (3, Patchptr, 1, Mapptr, 1, dot));
62. Matrix->set (Skmatrix::kmskewy, Skscalardotdiv (3, Patchptr, 1, mapptr+3, 1, dot));
64. Matrix->set (Skmatrix::kmpersp0, Skscalardotdiv (3, Patchptr, 1, mapptr+6, 1, dot));
68. //second column
70. Patchptr + = 3;
72. Matrix->set (Skmatrix::kmskewx, Skscalardotdiv (3, Patchptr, 1, Mapptr, 1, dot));
74. Matrix->set (Skmatrix::kmscaley, Skscalardotdiv (3, Patchptr, 1, mapptr+3, 1, dot));
76. Matrix->set (SKMATRIX::KMPERSP1, Skscalardotdiv (3, Patchptr, 1, mapptr+6, 1, dot));
80. //Third column
82. PATCHPTR = (const skscalar*) (const void*) &diff;
84. Matrix->set (SKMATRIX::KMTRANSX, Skscalardotdiv (3, Patchptr, 1, Mapptr, 1, dot));
86. Matrix->set (Skmatrix::kmtransy, Skscalardotdiv (3, Patchptr, 1, mapptr+3, 1, dot));
88. Matrix->set (SKMATRIX::KMPERSP2, SK_UNITSCALAR1);
92. }

Exploring the Android OpenGL projection matrix in depth of "rooting at the foot"