Разница между GlmultMatrixf+ Gltranslatef и моим эквивалентным (?) C ++ Код ⇐ C++

[Anonymous]

Проблема: выполнение эквивалентной матрицы математики до < /p>
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(Matrix4f::Rotation(ax,ay,az).AsArray());
glTranslatef(dx,dy,dz);
< /code>
создает другую результирующую матрицу C ++ ModelView, чем Opengl One в моем приложении в зависимости от AX, AY, AZ. < /p>
Я использую полный класс Matrix4f со всеми необходимыми операциями матрицы, частиц*, плюс код для создания, масштабирование и вращание (Matry matry, что является Matry re -matry, что является re -matry, что является Matry re -matry, что является re -matry, что является матрицей. реализованы. У меня Quintuple проверил свой код с помощью CHATGPT, он кажется на 100% правильным. < /P>
Для отладки я запускаю свой код матрицы, параллельно вызовам OpenGL, чтению матрицы OpenGL модели с использованием GlgetFloatv и сравнивая ее с моей собственной матрицей ModelView на каждом шаге. Мои операции C ++ полностью параллельны, поэтому для Glmultmatrixf (r) я также делаю mymodelview * = r и для Gltranslatef (dx, dy, dz) я делаю mymodelview = matrix4f :: translation (dx, dy, dz) * mymodelview. Мой класс Matrix - это мажор, поэтому я передаю линеаризованный транспонирование в OpenGL, как это: < /p>
glMultMatrixf (ModelView().Transpose(3).AsArray());
< /code>
transpose заботится о разрешении трансляционного вектора матрицы, хранящейся в индексах 12 - 14 в массиве линейных значений. < /p>
Проблема заключается в следующем: < /p>
, как только у меня будет вращение в mymodelview (), а затем и в моем переводе в моем коде: < /p> pretation
< /p> pretation < /p> < /p> < /p> pretation < /p> < /p> < /p> < /p> < /p> < /p> < /p>
ModelView() = Matrix4f::IDENTITY;
ModelView() = myModelView() * Matrix4f::Rotation(ax,ay,az);
ModelView() = Matrix4f::Translation(dx,dy,dz) * myModelView();
< /code>
Результат умножения матрицы отклоняется от результата GLTRANSLATEF для точной той же матрицы источника, например: < /p>
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(Matrix4f::Rotation(ax,ay,az).Transpose().AsArray());
glTranslatef(dx,dy,dz);
< /code>
Вот несколько соответствующих фрагментов кода. Сравнение матриц: < /p>
bool RenderMatrices::CheckModelView(void) {
float glData[16];
Shader::GetFloatData(GL_MODELVIEW_MATRIX, 16, glData); // calls glGetFloatv()
Matrix4f m = ModelView().Transpose(3);
float* a = m.AsArray();
for (int i = 0; i < 16; i++) {
if (abs(glData - a) > 0.001f) { // allow for minor differences
return false;
}
}
return true;
}

inline DATA_T Dot(const Vector& other) const { // DATA_T is float for Vector4f
DATA_T dot = (DATA_T)0;
for (int i = 0; i < componentCount; ++i) // componentCount is 4 for Vector4f
dot += m_data * other;
return dot;
}

Vector4f* Matrix4f::Mul(Vector4f* r, Vector4f* a, Vector4f* o) { // r = a * o
Vector4f t[4];
Vector4f* d = (r == a) ? t : r;
for (int col = 0; col < 4; ++col) {
Vector4f colVec{ o[0][col], o[1][col], o[2][col], o[3][col] };
for (int row = 0; row < 4; ++row) {
d[row][col] = a[row].Dot(colVec);
}
}
if (r == a)
memcpy(r, t, sizeof(t));
return r;
}

Matrix4f Matrix4f::operator* (Matrix4f& other) {
Matrix4f m;
Mul(m.m_data, m_data, other.m_data);
m.ToArray();
return m;
}

Matrix4f& RenderMatrices::Translate(float dx, float dy, float dz) {
Matrix4f t = Matrix4f::Translation(dx, dy, dz);
ModelView() = t * ModelView();
if (true or m_fixedRenderPipeline) {
glTranslatef(dx, dy, dz);
if (not CheckModelView())
mv = t * mv; // allow for checking multiplication in debugger
}
return ModelView();
}

Matrix4f& RenderMatrices::Rotate(Vector3f angles) {
Matrix4f r = Matrix4f::Rotation(angles, false);
ModelView() *= r.Transpose(); //*ModelView();
if (true or m_fixedRenderPipeline) {
glMultMatrixf(r.AsArray());
CheckModelView();
}
return ModelView();
}
< /code>
Относительно моей матрицы вращения: когда я подаю ее в Opengl, используя GlmultMatrixf, мой рендеринг работает нормально. Это указывает мне на то, что это правильно. < /P>
Это матрица ModelView только от OpenGL, содержащая вращение (основной столбец, поэтому ряды, отображаемые здесь, являются столбцами): < /p>
[ 0.999876618 0.00000000 0.0157073177 0.00000000 ]
[ 0.00000000 1.00000000 0.00000000 0.00000000 ]
[ -0.0157073177 0.00000000 0.999876618 0.00000000 ]
[ 0.00000000 0.00000000 0.00000000 1.00000000 ]
< /code>
Это идентично матрице модели, поддерживаемой в моем коде C ++, поэтому следующий перевод выполняется на одних и тех же значениях численной матрицы от OpenGL и от меня. Перевод: < /p>
-4.65000010, -0.750000000, 16.9500027
< /code>
Тем не менее, результат умножения матрицы перевода из этих значений с моей матрицей C ++ ModelView и GLTRANSLATEF отличается. Для OpenGL, TX, TY, TZ < /p>
-4.91566563, -0.750000000, 16.8748741
< /code>
Для c ++ они < /p>
-4.38318729, -0.750000000, 17.0209503
< /code>
Значения C ++ являются результатом точечных продуктов, рассчитанных при выполнении Matrix4f :: translation (dx, dy, dz) * modelview (). < /p>
Я не уверен, что Opengl здесь делает иначе. Я имею в виду, что точечные продукты и умножения матрицы очень хорошо определены, не так ли? Как это исправить?

Подробнее здесь: https://stackoverflow.com/questions/796 ... ent-c-code