使用GLM创建OpenGL的转换矩阵(旋转)

3

原问题:

问题

我有一个单位立方体,我想将其变换,使其连接两个点。 我是OpenGL的新手,只了解线性代数的最基本部分。我尝试模仿极坐标类似的东西来连接点。当Z轴和另一个轴发生变化时,我的当前实现不起作用。我还尝试过mat = glm :: lookAt(center,terminal,y_axis);,但没有成功。

代码

这来自于位于schedule_edge_update()中的for循环体。

auto const initial = p1;
auto const terminal = p2;
auto const distance = glm::distance(initial, terminal);
auto const length = distance * 0.5f;
auto const center = (initial + terminal) / 2.f;
auto const rejection = terminal - initial;
auto const delta = glm::normalize(rejection);

auto mat = glm::mat4(1);

// translate
mat = glm::translate(mat, center);

// rotate
auto const phi_hyp = glm::length(glm::vec2(delta.x, delta.z));
if (phi_hyp != 0.0f) {
    auto phi = acosf(delta.x / phi_hyp);
    mat = glm::rotate(mat, phi, y_axis);
}

auto const theta_hyp = glm::length(glm::vec2(delta.x, delta.y));
if (theta_hyp != 0.0f) {
    auto theta = acosf(delta.x / theta_hyp);
    theta *= delta.x > 0 ? -1.0f : 1.0f;
    mat = glm::rotate(mat, theta, z_axis);
}

// scale
edges->add_matrix(glm::scale(mat, glm::vec3(length, 0.05f, 0.01f)));

当一个矩阵被添加到edges中时,它会被排队缓冲以进行实例渲染。

远方

这里是我的测试点和一个我做的大立方体。 Far away

近距离

这是一个不起作用的示例。初始点标记为p1,终端点标记为p2。未连接任何点的线应该连接p1和p2。 Close up

不同的近距离

这是另一个示例,但这个示例有p1和p2的坐标标记。p1和p2在Y和Z上有所变化。然而,我的代码将立方体(在平移后)绕y轴旋转90度,然后对其进行缩放。你可以看出它被旋转了,因为它在一个轴上更宽(旋转之前的y轴)。 Different Close Up

完整坐标列表

// Test points
auto const A = glm::vec3(-10.0f, -10.0f, -20.0f);
auto const B = glm::vec3(+10.0f, -10.0f, -20.0f);
auto const C = glm::vec3(+10.0f, +10.0f, -20.0f);
auto const D = glm::vec3(+00.0f, +10.0f, -20.0f);
auto const E = glm::vec3(+05.0f, +05.0f, -20.0f);
auto const F = glm::vec3(+00.0f, +00.0f, -30.0f);
auto const G = glm::vec3(-10.0f, -10.0f, -30.0f);
auto const H = glm::vec3(+55.0f, -15.0f, -60.0f);
auto const I = glm::vec3(+55.0f, -05.0f, -70.0f);

get_nodes().emplace_back(A);
get_nodes().emplace_back(B);
get_nodes().emplace_back(C);
get_nodes().emplace_back(D);
get_nodes().emplace_back(E);
get_nodes().emplace_back(F);
get_nodes().emplace_back(G);
get_nodes().emplace_back(H);
get_nodes().emplace_back(I);

get_edges().emplace_back(A, B);
get_edges().emplace_back(B, C);
get_edges().emplace_back(C, D);
get_edges().emplace_back(D, E);
get_edges().emplace_back(E, F);
get_edges().emplace_back(F, G);
get_edges().emplace_back(G, H);
get_edges().emplace_back(H, I);

// Big cube
auto const C0 = glm::vec3(-5.0f, -5.0f, -5.0f);
auto const C1 = glm::vec3(-5.0f, -5.0f, +5.0f);
auto const C2 = glm::vec3(-5.0f, +5.0f, -5.0f);
auto const C3 = glm::vec3(-5.0f, +5.0f, +5.0f);
auto const C4 = glm::vec3(+5.0f, -5.0f, -5.0f);
auto const C5 = glm::vec3(+5.0f, -5.0f, +5.0f);
auto const C6 = glm::vec3(+5.0f, +5.0f, -5.0f);
auto const C7 = glm::vec3(+5.0f, +5.0f, +5.0f);

get_nodes().emplace_back(C0);
get_nodes().emplace_back(C1);
get_nodes().emplace_back(C2);
get_nodes().emplace_back(C3);
get_nodes().emplace_back(C4);
get_nodes().emplace_back(C5);
get_nodes().emplace_back(C6);
get_nodes().emplace_back(C7);

get_edges().emplace_back(C0, C1);
get_edges().emplace_back(C0, C2);
get_edges().emplace_back(C0, C4);
get_edges().emplace_back(C1, C3);
get_edges().emplace_back(C1, C5);
get_edges().emplace_back(C2, C3);
get_edges().emplace_back(C2, C6);
get_edges().emplace_back(C3, C7);
get_edges().emplace_back(C4, C5);
get_edges().emplace_back(C4, C6);
get_edges().emplace_back(C5, C7);
get_edges().emplace_back(C6, C7);

schedule_node_update();
schedule_edge_update();

使用GLM的Spektre解决方案

代码

auto constexpr A = vec3(-0.5f, 0.0f, 0.0f);
auto constexpr B = vec3(+0.5f, 0.0f, 0.0f);
auto const C = p1;
auto const D = p2;

auto M = mat4(1.0f);

// Translate
auto const center = 0.5 * (C + D);
M = translate(M, center);

// Rotate
auto constexpr p = B - A;
auto const q = D - C;
auto const n = cross(p, q);
if (n != vec3()) {
    auto const a = angle(normalize(p), normalize(q));
    M = rotate(M, a, n);
}

// Scale
auto constexpr thickness = 0.05f;
M = scale(M, vec3(0.5f * distance(C, D), thickness, thickness));

edges->add_matrix(M);

成功的结果

成功的结果


1
你想要实现什么目标还不清楚!你所说的通过矩阵连接两个点是什么意思?是哪两个点?你是否类似于海龟绘图构建立方体?矩阵并不能连接任何东西,它只能定位、定向和缩放一些几何形状。在你的示例中我没有看到相关的代码,也没有渲染,没有几何形状,也没有控制代码(可以解释你试图做什么)。请稍微编辑一下你的问题,让它更加清晰明了。 - Spektre
@Spektre 我正在尝试将一个单位立方体从原点移动到两个节点之间。然后旋转和缩放它,使其连接这些节点。https://imgur.com/a/U2nxItB 我可以链接存储库,但控制代码非常大。立方体和球体是通过.obj文件加载的。 - user1032677
1
所以你想让你的立方体对角线从2个点开始/结束?你知道立方体的中心、大小、方向(理想情况下是2个对角线点的位置)吗?还有你想让立方体碰到的那2个点? - Spektre
1
所以,轴对齐的立方体是1. 以(0,0,0)为中心,边长为12或2. (0,0,0)是一个对角点,(1,1,1)是另一个对角点?你的图片表明是后者。 - Spektre
2
我成功完成了编辑,请查看我的答案。 - Spektre
显示剩余7条评论
1个回答

5
所以问题归结为:
我知道4个点A、B、C、D,我想计算一个变换矩阵,将A、B转换成C、D。

overview

这可以这样做。假设我们像这样转换点:

M * A = C
M * B = D

其中M是我们要计算的变换矩阵。由于线段AB可以绕其自身轴任意旋转,因此存在无限数量的可能解。

如果你稍微分析一下M,那么它只涉及到位置、方向和比例尺度的问题。

  1. 比例尺是最简单的

    它只是变换前后线段长度之比。

    scale = |CD|/|AB|
    
  2. 方向

    它由单位基向量表示。我们可以利用 AB 和 CD 只有单一旋转(其他所有旋转都会产生无限多个解)的事实,因此我们可以围绕垂直于 AB、CD 的轴将 AB 按照 AB、CD 之间的角度旋转,得到 CD。我们可以通过 AB、CD 平行的单位向量的点积的反余弦来获得角度。唯一的问题是这不会给我们旋转方向,所以我们需要测试两种可能性(顺时针和逆时针)。

    所以:

     axis  = cross(B-A,D-C)
     angle = +/- acos(dot(B-A,D-C) / |B-A|*|D-C|)
    
  3. 平移

    这个很简单,我们只需在不进行平移的情况下使用 M 对 A 进行变换,称其为 A',然后仅纠正结果位置,使其到达 C。

    M_origin += C-A'
    

    请注意,应直接设置平移,而不是应用平移矩阵。这些通常在局部坐标系 [LCS] 中进行转换,需要先将差异转换为它。在这种情况下,请使用

    translate(Inverse(M)*(C-A'))
    

    或者

    translate(M*(C-A'))
    

    取决于所使用的符号。

这里是一个小的C++/VCL/old GL示例:

//---------------------------------------------------------------------------
#include <vcl.h>
#include <math.h>
#pragma hdrstop
#include "Unit1.h"
#include "gl_simple.h"
#include "OpenGLrep4d_double.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
double arot=0.0;                // just animation angle
//---------------------------------------------------------------------------
const int pnts=8;
double pnt[pnts*3]=             // Vertexes for 10x10x10 cube centered at (0,0,0)
    {
    -5.0,-5.0,-5.0,
    -5.0,+5.0,-5.0,
    +5.0,+5.0,-5.0,
    +5.0,-5.0,-5.0,
    -5.0,-5.0,+5.0,
    -5.0,+5.0,+5.0,
    +5.0,+5.0,+5.0,
    +5.0,-5.0,+5.0,
    };
const int lins=12;
int lin[lins*2]=                // lines (index of point used) no winding rule
    {
    0,1,1,2,2,3,3,0,
    4,5,5,6,6,7,7,4,
    0,4,1,5,2,6,3,7,
    };
double A[3]={-5.0,-5.0,-5.0};   // cube diagonal
double B[3]={+5.0,+5.0,+5.0};
double C[3]={-4.5, 2.0, 0.0};   // wanted cube diagonal
double D[3]={+4.5, 5.0, 0.0};
double M[16];                   // our transform matrix
//---------------------------------------------------------------------------
void compute_M()
    {
    double scale,p[3],q[3],n[3],a;
    const double deg=180.0/M_PI;
    const double rad=M_PI/180.0;
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();

    // scale
    vector_sub(p,B,A);                      // p=B-A
    vector_sub(q,D,C);                      // q=D-C
    scale=vector_len(q)/vector_len(p);      //  =|q|/|p|

    // rotation between AB and CD
    vector_mul(n,p,q);                      // n = (p x q) ... cross product
    vector_one(p,p);                        // p = p/|p|
    vector_one(q,q);                        // q = q/|q|
    a=acos(vector_mul(p,q));                // angle between AB and CD in [rad]

    glLoadIdentity();                       // unit matrix
    glRotated(+a*deg,n[0],n[1],n[2]);       // rotate by angle around normal to AB,CD
    glScaled(scale,scale,scale);            // apply scale
    glGetDoublev(GL_MODELVIEW_MATRIX,M);    // get the M from OpenGL

    // translation
    matrix_mul_vector(p,M,A);               // p = M*A
    vector_sub(p,C,p);                      // p = C-p
    M[12]=p[0];
    M[13]=p[1];
    M[14]=p[2];
    M[15]=1.0;

    // verify
    matrix_mul_vector(p,M,B);               // p = M*B
    vector_sub(p,p,D);                      // p = p-C
    if (vector_len(p)>1e-3)                 // if |p| too big use other direction to rotate
        {
        glLoadIdentity();                       // unit matrix
        glRotated(-a*deg,n[0],n[1],n[2]);       // rotate by angle around normal to AB,CD
        glScaled(scale,scale,scale);            // apply scale
        glGetDoublev(GL_MODELVIEW_MATRIX,M);    // get the M from OpenGL
        }

    glPopMatrix();
    }
//---------------------------------------------------------------------------
void gl_draw()      // main rendering code
    {
    int i;
    double m0[16],m1[16],m[16],x[3],y[3],z[3],t2[3][3];

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glDisable(GL_CULL_FACE);
    glEnable(GL_DEPTH_TEST);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslated(0.0,0.0,-50.0);
    glRotated(15.0,1.0,0.0,0.0);
    glRotated(arot,0.0,1.0,0.0);

    glBegin(GL_LINES);
    glColor3f(1.0,0.0,0.0); for (i=0;i<lins*2;i++) glVertex3dv(pnt+(lin[i]*3)); // render original cube
    glColor3f(0.0,1.0,0.0); glVertex3dv(A); glVertex3dv(B);                     // render original diagonal AB
    glColor3f(1.0,1.0,0.0); glVertex3dv(C); glVertex3dv(D);                     // render wanted diagonal CD
    glEnd();

    // render transformed cube
    glMatrixMode(GL_MODELVIEW);
    glMultMatrixd(M);
    glBegin(GL_LINES);
    glColor3f(0.0,0.0,1.0); for (i=0;i<lins*2;i++) glVertex3dv(pnt+(lin[i]*3)); // render transformed cube
    glEnd();


    glFlush();
    SwapBuffers(hdc);
    }
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner):TForm(Owner)
    {
    // application init
    gl_init(Handle);
    compute_M();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormDestroy(TObject *Sender)
    {
    // application exit
    gl_exit();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormResize(TObject *Sender)
    {
    // window resize
    gl_resize(ClientWidth,ClientHeight);
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormPaint(TObject *Sender)
    {
    // window repaint
    gl_draw();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
    {
    arot+=1.5; if (arot>=360.0) arot-=360.0;
    gl_draw();
    }
//---------------------------------------------------------------------------

只需忽略与VCL相关的内容。您可以在此处找到GL支持函数:

这里唯一重要的是compute_M()以及全局变量。

向量数学函数已经注释(因此您可以将其翻译为GLM),如果您需要实现,可以在上面链接的QA中找到它们。基本上采用。为简单起见,我使用了GL本地旋转(请注意,它们以度而非弧度为单位)。

这是预览:

preview

  • 红色 是原始立方体
  • 绿色 是原始对角线 AB
  • 蓝色 是通过 M 变换的立方体
  • 黄色 是所需对角线 CD

如您所见,它们匹配。

如果您需要对齐多行,则需要添加更多信息以进行对齐(例如2行(3个点)等)。有关更多信息,请参见:


网页内容由stack overflow 提供, 点击上面的
可以查看英文原文,
原文链接