标签: glm-math

我在按照本教程尝试使用 GLM 进行矩阵和向量相乘时遇到此错误。

reading1.cpp: In function \xe2\x80\x98int main()\xe2\x80\x99:\nreading1.cpp:50:44: error: conversion from \xe2\x80\x98glm::detail::tmat4x4<int>\xe2\x80\x99 to non-scalar type \xe2\x80\x98glm::mat4 {aka glm::detail::tmat4x4<float>}\xe2\x80\x99 requested\n

我正在使用这个命令来编译。

g++ 1.cpp -o 1 -lGLEW -lglfw

#include <glm/glm.hpp>\n#include <glm/gtx/transform.hpp>\n\n//program\n\n\n\nglm::mat4 myMatrix = glm::translate(10,0,0);\nglm::vec4 myVector(10,10,10,0);\nglm::vec4 transformedVector = myMatrix * myVector;\n\n//program\n

我正在尝试使用 glm 创建一个视图矩阵。我知道glm::lookAt并理解它是如何工作的。我想知道是否有类似的函数可以使用不同的参数实现相同的结果。例如，是否有一个函数接受一个向上的向量、一个垂直于该向量的平面上的方向方位（？）和一个角度？（即天空是那样的，我向左转 N 度/弧度并向上倾斜我的头 M 度/弧度）。

什么是a，glm::vec2它的应用是什么？我在 glm 参考中找不到它。不过，我可以找到 vec1。这让我认为这vec2是针对 2D 的，vec3是针对 3D 的，等等，但我可能是错的。

我试图更好地理解 glm::ortho 的工作原理，源代码 (v 0.9.7) 如下所示：

template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> ortho
(
    T left,
    T right,
    T bottom,
    T top,
    T zNear,
    T zFar
)
{
    tmat4x4<T, defaultp> Result(1);
    Result[0][0] = static_cast<T>(2) / (right - left);
    Result[1][1] = static_cast<T>(2) / (top - bottom);
    Result[2][2] = - static_cast<T>(2) / (zFar - zNear);
    Result[3][0] = - (right + left) / (right - left);
    Result[3][1] = - (top + bottom) / (top - bottom);
    Result[3][2] = - (zFar + zNear) / …

我想检查 aglm::vec3是否等于零向量glm::vec3(0,0,0)。

直到现在我在写

if(v == glm::vec3(0,0,0))
    ...

但后来我了解了 epsilon，所以我的问题是，是否有一种更快（更具可读性）的方法来进行此检查，而不是像这样进行显式比较：

if(abs(v.x) < EPSILON && abs(v.y) < EPSILON && abs(v.z) < EPSILON)
    ...

我正在构建一个相机课程，并从构建该课程的在线教程中获得了帮助。

现在我想在相机中添加滚动条，但找不到任何阅读材料来解释如何在相机中添加滚动条。

Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 500.0f), glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), Zoom(ZOOM)
    {
        Position = position;
        WorldUp = up;
        Yaw = yaw;
        Pitch = pitch;
        updateCameraVectors();
    }

glm::mat4 GetViewMatrix()
    {
        return glm::lookAt(Position, Position + Front , Up);
    }

void updateCameraVectors()
    {
        
        glm::vec3 front;
        front.x = cos(glm::radians(Yaw - 90)) * cos(glm::radians(Pitch));
        front.y = sin(glm::radians(Pitch));
        front.z = sin(glm::radians(Yaw - 90)) * cos(glm::radians(Pitch)) ;
        Front = glm::normalize(front);
        Right …

我目前正在试验 OpenGL，我遇到了一种情况，我想找到 4x4 矩阵x，其中x * mat1 = mat2（列主要顺序，我认为。wherex * mat1意味着应用 中的转换mat1，然后x.）。

自然，我认为解决方案可能是x = mat2 / mat1，所以我用 glm 尝试了它。它奏效了！以下代码段将输出true.

glm::mat4 mat1 = glm::translate(glm::vec3{1,2,3});
glm::mat4 mat2 = glm::scale(glm::vec3{-1,-2,-3});

glm::mat4 x = mat2 / mat1;
std::cout << ((x * mat1) == mat2) << std::endl;

但后来，我意识到了mat1 * x != x * mat1！这有什么意义？mat2 / mat1会模棱两可！我的除法解对找到 x 是否令人满意，或者有什么注意事项吗？（同样，我的目标是拥有x * mat1 = mat2）

我也遇到了这个讨论：https : //math.stackexchange.com/questions/228229/is-division-of-matrices-possible?newreg=c7fd79a48ae54ed694af1ee5f4646af7

我正在尝试使用 glm 旋转纹理图像，但输出看起来被拉伸或未沿 z 轴正确旋转。对于这个问题，可能的解决方案是什么？

float imgAspectRatio = imageWidth / (float) imageHeight;
float viewAspectRatio = viewWidth / (float) viewHeight;

if (imgAspectRatio > viewAspectRatio) {
    yScale = viewAspectRatio / imgAspectRatio;
} else {
    xScale = imgAspectRatio / viewAspectRatio;
}

glm::mat4 model(1.0f);
model = glm::translate(model, glm::vec3(0, 0, 0));
model = glm::rotate(model, glm::radians(angle),
                    glm::vec3(0, 0, 1));
model = glm::scale(model, glm::vec3(xScale, yScale, 1.0f));

有些人建议与 glm::ortho 相乘，但它给出的是正方形

glm::mat4 projection(1.0f);    
projection = glm::ortho(
              -imgAspectRatio,             
              imgAspectRatio,              
              -1.0f,      
              1.0f,       
              -1.0f,              
              1.0f                
      );

编辑：这对我来说是“倒退”——我可能缺少一些直觉

给定一个 glm 变换函数，例如 glm::translate，这两个参数首先是一个矩阵m，然后是一个用于平移的向量v。

直观地说，我希望这个函数在我的矩阵变换“之后”应用翻译，即将一个对象乘以返回的矩阵将首先应用m然后是指定的翻译v。

这种直觉来自这样一个事实，即人们通常以数学顺序构建一个变换，例如首先计算一个比例矩阵，然后应用旋转，然后变换等。所以我认为函数调用顺序是相同的（即给定一个矩阵，我可以只需调用glm::translate即可应用在应用我的矩阵变换后发生的平移）

然而，正如在这个线程中提到的，情况并非如此——首先应用翻译，然后是传入的矩阵m。

我认为这与某些线程建议的列主要/行主要约定和符号没有任何关系。这有历史原因吗？这对我来说似乎有点倒退，除非有足够的理由，否则我可能会重写这些函数。

我有点惊讶.我一直在调试我的代码几个小时,而GLM似乎放弃了我.我正在努力完成以下两个实例:

....
cout << "multiplying A:" << endl;
displayMatrix(node->wMatrix);

cout << "and B:" << endl;
displayMatrix((node->children)[i]->wMatrix);

//switch order!
mat4 temp = (node->children)[i]->wMatrix * node->wMatrix;

cout << "Get result as:" << endl;
displayMatrix(temp);
...

displayMatrix方法如下:

void displayMatrix(mat4 &m)
{
    cout << m[0][0] << "  " << m[0][1] << "  " << m[0][2] << "  " << m[0][3] << endl;
    cout << m[1][0] << "  " << m[1][1] << "  " << m[1][2] << "  " << m[1][3] << endl;
    cout << …