# OpenGL Simple OpenGL matrix question

## Recommended Posts

I'm kind of confused about how opengl matrices work. Say i have a rotation around the Z axis. _mij are sequential in memory, that is _m12 follows immediately after _m11 and _m21 follows just after _m14.

_m11 = cosAngle; _m12 = sinAngle; _m13  = 0.0f; _m14 = 0.0f;
_m21 = -sinAngle; _m22 = cosAngle; _m23 = 0.0f; _m24 = 0.0f;
_m31 = 0.0f; _m32 = 0.0f; _m33 = 1.0f; _m34 = 0.0f;
_m41 = 0.0f; _m42 = 0.0f; _m43 = 0.0f; _m44 = 1.0f;


If i load this with glLoadMatrixfv i obtain the same results as when calling glRotatef(30,0,0,1).When calling glGetFloatf with GL_MODELVIEW_MATRIX i obtain the same results with both methods(glLoadMatrixf and glRotatef). But if i want to correctly transform a column vector and obtain the same results as when opengl transforms it with this matrix i have to post multiply with the my matrix, like this: transformedVertex = Transpose(Transpose(transformedVertex) * myMatrix). but opengl Premultiplies a vector with a matrix like this: transformedVertex = myMatrix * transformedVertex. Why is this difference? Does OpenGL store my matrix inverted in memory? What about retriveal of the matrix from OpenGL?

##### Share on other sites
The matrix you show, given the linear order of the elements, is a row-major matrix. Elements are linearized row by row. OpenGL's matrices are column major, and they are the transpose of what you presented aswell.

This transposed and majorness change cancel each other, which means you can upload the matrix stored in row-major order, and get the same result as OpenGL's rotation matrix stored in column-major order.

There will, however, be a difference if you try to multiply the matrices something. The matrix you show must be multiplied by a row vector on the left hand side to get the same result as OpenGL, which multiplies a column-vector on the right side.

##### Share on other sites
Quote:
 Original post by Brother BobThe matrix you show, given the linear order of the elements, is a row-major matrix. Elements are linearized row by row. OpenGL's matrices are column major, and they are the transpose of what you presented aswell.This transposed and majorness change cancel each other, which means you can upload the matrix stored in row-major order, and get the same result as OpenGL's rotation matrix stored in column-major order.There will, however, be a difference if you try to multiply the matrices something. The matrix you show must be multiplied by a row vector on the left hand side to get the same result as OpenGL, which multiplies a column-vector on the right side.

Please excuse my noobiness but i did not catch it completely. Say i have this matrix in row major order(laid continous in memory):

X.x X.y X.z t.x
Y.x Y.y Y.z t.y
Z.x Z.y Z.z t.z
0 0 0 1

I need to convert it to column major order(laid continous in memory):
X.x Y.x Z.x 0
X.y Y.y Z.y 0
X.z Y.z Z.z 0
t.x t.y t.z 1

Now what?! As far as i understand OpenGL stores the basis vectors one after another in memory and if this would be so then it effectively becomes:
X.x X.y X.z t.x
Y.x Y.y Y.z t.y
Z.x Z.y Z.z t.z
0 0 0 1

which is the form we started with in the first place.
Is this right?! :D

##### Share on other sites
The matrix you presented in your original post is a row base vector matrix and must be transposed to match the matrices used by OpenGL. Base vectors in OpenGL are column. So a matrix for a rotation about the Z-axis is in OpenGL is (s and c means sine and cosine of the angle to rotate):
c -s  0  0s  c  0  00  0  1  00  0  0  1

This is transposed to your matrix. Linearize this in column-major order, you get this array.
c  s  0  0 -s c  0  0  0  0  1  0  0  0  0  1

If you linearize your matrix in row-major order, you get the same memory layout (which is why you can pass "double-wrong" to OpenGL and get correct result), but multiplication with a column vector to the right is different, because the matrices are transposed.

##### Share on other sites
Quote:
 Original post by Brother BobThe matrix you presented in your original post is a row base vector matrix and must be transposed to match the matrices used by OpenGL. Base vectors in OpenGL are column. So a matrix for a rotation about the Z-axis is in OpenGL is (s and c means sine and cosine of the angle to rotate):c -s 0 0s c 0 00 0 1 00 0 0 1This is transposed to your matrix. Linearize this in column-major order, you get this array.c s 0 0 -s c 0 0 0 0 1 0 0 0 0 1If you linearize your matrix in row-major order, you get the same memory layout (which is why you can pass "double-wrong" to OpenGL and get correct result), but multiplication with a column vector to the right is different, because the matrices are transposed.

YEY! I finally understand it! I've been struggling with this thing for quite a time :D.

## Create an account

Register a new account

• ## Partner Spotlight

• ### Forum Statistics

• Total Topics
627644
• Total Posts
2978366
• ### Similar Content

• By xhcao
Before using void glBindImageTexture(    GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format), does need to make sure that texture is completeness.
• By cebugdev
hi guys,
are there any books, link online or any other resources that discusses on how to build special effects such as magic, lightning, etc. in OpenGL? i mean, yeah most of them are using particles but im looking for resources specifically on how to manipulate the particles to look like an effect that can be use for games,. i did fire particle before, and I want to learn how to do the other 'magic' as well.
Like are there one book or link(cant find in google) that atleast featured how to make different particle effects in OpenGL (or DirectX)? If there is no one stop shop for it, maybe ill just look for some tips on how to make a particle engine that is flexible enough to enable me to design different effects/magic
let me know if you guys have recommendations.
• By dud3
How do we rotate the camera around x axis 360 degrees, without having the strange effect as in my video below?
Mine behaves exactly the same way spherical coordinates would, I'm using euler angles.
Tried googling, but couldn't find a proper answer, guessing I don't know what exactly to google for, googled 'rotate 360 around x axis', got no proper answers.

References:
Code: https://pastebin.com/Hcshj3FQ
The video shows the difference between blender and my rotation:

• By Defend
I've had a Google around for this but haven't yet found some solid advice. There is a lot of "it depends", but I'm not sure on what.
My question is what's a good rule of thumb to follow when it comes to creating/using VBOs & VAOs? As in, when should I use multiple or when should I not? My understanding so far is that if I need a new VBO, then I need a new VAO. So when it comes to rendering multiple objects I can either:
* make lots of VAO/VBO pairs and flip through them to render different objects, or
* make one big VBO and jump around its memory to render different objects.
I also understand that if I need to render objects with different vertex attributes, then a new VAO is necessary in this case.
If that "it depends" really is quite variable, what's best for a beginner with OpenGL, assuming that better approaches can be learnt later with better understanding?

• Hello all,

On my Windows 7 x64 machine I wrote the code below on VS 2017 and ran it.
#include <glad/glad.h>  #include <GLFW/glfw3.h> #include <std_lib_facilities_4.h> using namespace std; void framebuffer_size_callback(GLFWwindow* window , int width, int height) {     glViewport(0, 0, width, height); } //****************************** void processInput(GLFWwindow* window) {     if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)         glfwSetWindowShouldClose(window, true); } //********************************* int main() {     glfwInit();     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);     //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);     GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", nullptr, nullptr);     if (window == nullptr)     {         cout << "Failed to create GLFW window" << endl;         glfwTerminate();         return -1;     }     glfwMakeContextCurrent(window);     if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))     {         cout << "Failed to initialize GLAD" << endl;         return -1;     }     glViewport(0, 0, 600, 480);     glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);     glClearColor(0.2f, 0.3f, 0.3f, 1.0f);     glClear(GL_COLOR_BUFFER_BIT);     while (!glfwWindowShouldClose(window))     {         processInput(window);         glfwSwapBuffers(window);         glfwPollEvents();     }     glfwTerminate();     return 0; }
The result should be a fixed dark green-blueish color as the end of here. But the color of my window turns from black to green-blueish repeatedly in high speed! I thought it might be a problem with my Graphics card driver but I've updated it and it's: NVIDIA GeForce GTX 750 Ti.
What is the problem and how to solve it please?

• 10
• 12
• 22
• 13
• 33