OpenGL做一个坐标系指示方位

已于 2022-04-05 17:33:03 修改
阅读量2.6k 收藏 25
点赞数 7
分类专栏： 笔记 文章标签： opengl 渲染管线 c++
于 2022-04-03 14:23:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/garyaofq/article/details/123936927
版权

我们试着用OpengGL来画一个坐标系，方便我们知道我们的模型当前的位置和方向。做好的坐标系类似下面的效果（中间的停顿效果是因为绘图程序是用主程序的空余时间来画的，如果鼠标按住标题栏，标题栏重绘的时候，就不会处理绘图程序了）。

OpenGL除了能画3D模型，渲染外，也可以画线。下面是一段画坐标箭头的代码，供参考。

首先要加载数据到缓存区

//箭头数据，每两个点为一组，画一条线段    
glm::vec3 box[34] = {
		{ 0, 0, 0.f },
		{ 1, 0, 0.f },
		{ 1, 0, 0.f },
		{ 0.7, 0.1, 0.f },
		{ 1, 0, 0.f },
		{ 0.7, -0.1, 0.f },
        { 1.2, 0.1, 0.f },
        { 1.3, -0.1, 0.f },
        { 1.2, -0.1, 0.f },
        { 1.3, 0.1, 0.f },

		{ 0, 0, 0.f },
		{ 0, 1, 0.f },
		{ 0, 1, 0.f },
		{ 0.1, 0.7, 0.f },
		{ 0, 1, 0.f },
		{ -0.1, 0.7, 0.f },
		{ 0.05, 1.3, 0.f },
        { 0, 1.2, 0.f },
        { -0.05, 1.3, 0.f },
        { 0, 1.2, 0.f },
        { 0, 1.2, 0.f },
        { 0, 1.1, 0.f },

        { 0, 0, 0.0f },
		{ 0, 0, 1.0f },
		{ 0, 0, 1.0f },
		{ 0.1, 0.0, 0.7f },
		{ 0, 0, 1.0f },
		{ -0.1, 0.0, 0.7f },
		{ -0.05, 0, 1.2f },
		{ 0.05, 0, 1.2f },
		{ 0.05, 0, 1.2f },
		{ -0.05, 0.0, 1.1f },
		{ -0.05, 0, 1.1f },
		{ 0.05, 0.0, 1.1f }
	};
	std::vector<float> pvalues;
     for(int i=0;i<sizeof(box);i++)
    {
        pvalues.push_back(box[i][0]);
        pvalues.push_back(box[i][1]);
        pvalues.push_back(box[i][2]);
    }

    glGenVertexArrays(1,vao);
    glGenBuffers(1,vbo);
    //绑定到vao
    glBindVertexArray(vao[0]);
    glBindBuffer(GL_ARRAY_BUFFER,vbo[0]);
    //缓存数据
    glBufferData(GL_ARRAY_BUFFER,pvalues.size()*4,&pvalues[0],GL_STATIC_DRAW);
    //指定数据格式
    glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,0,0);
    glEnableVertexAttribArray(0);
    //松绑
    glBindVertexArray(0);

绘图代码如下：

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
glDepthFunc(GL_LEQUAL);
/获取统一变量地址
scene.mvLoc=glGetUniformLocation(renderingProgram,"mv_matrix");

    scene.vMat=glm::translate(glm::mat4(1.0f),glm::vec3(-camera.camerax,-camera.cameray,-camera.cameraz));               scene.mMat=glm::translate(glm::mat4(1.0f),glm::vec3(mytorus.locx,mytorus.locy,mytorus.locz));
    scene.mMat*= glm::rotate(glm::mat4(1.0f), (float)(mytorus.rotateangle),glm::vec3(1.0f,1.0f,0.0f));
    scene.mvMat=scene.vMat*scene.mMat;
glUniformMatrix4fv(scene.mvLoc,1,GL_FALSE,glm::value_ptr(scene.mvMat));

glBindVertexArray(vao[0]);
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glColor3f(0.f, 1.f, 1.f);
glLineWidth(5.0f);

glDrawArrays(GL_LINES, 0, 34);

glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glBindVertexArray(0);

效果图如下

也可以添加线条做成网格

结合圆环的绘制和变换矩阵，可以得到下面的动画效果：

熟悉GLSL的可以通过增加一个变量，将纹理颜色和普通颜色区分出来，就可以得到下面的结果。

 顶点着色器代码：

#version 430

layout (location = 0) in vec3 position;
layout (location = 1) in vec2 tex_coord;
layout (location = 2) in vec4 dcolor;
out vec2 tc;
out vec4 dc;
uniform mat4 mv_matrix;
uniform mat4 proj_matrix;
layout (binding=0) uniform sampler2D s;

void main(void)
{	gl_Position = proj_matrix * mv_matrix * vec4(position,1.0);
	tc = tex_coord;
	dc=dcolor;
}

片段着色器代码：

#version 430

in vec2 tc;
in vec4 dc;
out vec4 color;

uniform mat4 mv_matrix;
uniform mat4 proj_matrix;
layout (binding=0) uniform sampler2D s;

void main(void)
{
	if(dc[3]==1.0f)
    {
        color=dc;
    }else
    {
        color = texture(s,tc);
    }
}

最后贴出整个主程序的代码（绘图代码有点啰嗦，懂vao的自己简化下）：

#include <windows.h>
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#include <gl/gl.h>

#include "Globalv.h"

using namespace std;

void LoadAxle(void)
{
    glm::vec3 box[54] = {
        //x轴
		{ 0.0f, 0.0f, 0.0f },
		{ 5.0f, 0.0f, 0.0f },
		{ 5.0f, 0.0f, 0.0f },
		{ 4.7f, 0.1f, 0.0f },
		{ 5.0f, 0.0f, 0.0f },
		{ 4.7f, -0.1f, 0.0f },
        { 5.2f, 0.1f, 0.0f },
        { 5.3f, -0.1f, 0.0f },
        { 5.2f, -0.1f, 0.0f },
        { 5.3f, 0.1f, 0.0f },
        //y轴
		{ 0.0f, 0.0f, 0.0f },   //10
		{ 0.0f, 5.0f, 0.0f },
		{ 0.0f, 5.0f, 0.0f },
		{ 0.1f, 4.7f, 0.0f },
		{ 0.0f, 5.0f, 0.0f },
		{ -0.1f, 4.7f, 0.0f },
		{ 0.05f, 5.3f, 0.0f },
        { 0.0f, 5.2f, 0.0f },
        { -0.05f, 5.3f, 0.0f },
        { 0.0f, 5.2f, 0.0f },
        { 0.0f, 5.2f, 0.0f },
        { 0.0f, 5.1f, 0.0f },
        //z轴
        { 0.0f, 0.0f, 0.0f },   //22
		{ 0.0f, 0.0f, 5.0f },
		{ 0.0f, 0.0f, 5.0f },
		{ 0.1f, 0.0f, 4.7f },
		{ 0.0f, 0.0f, 5.0f },
		{ -0.1f, 0.0f, 4.7f },
		{ -0.05f, 0.0f, 5.2f },
		{ 0.05f, 0.0f, 5.2f },
		{ 0.05f, 0.0f, 5.2f },
		{ -0.05f, 0.0f, 5.1f },
		{ -0.05f, 0.0f, 5.1f },
		{ 0.05f, 0.0f, 5.1f },

        //网格横线
		{ 0.0f, 0.0f, 0.0f },   //34
		{ 0.0f, 4.0f, 0.0f },
		{ 1.0f, 0.0f, 0.0f },
		{ 1.0f, 4.0f, 0.0f },
		{ 2.0f, 0.0f, 0.0f },
		{ 2.0f, 4.0f, 0.0f },
		{ 3.0f, 0.0f, 0.0f },
		{ 3.0f, 4.0f, 0.0f },
		{ 4.0f, 0.0f, 0.0f },
		{ 4.0f, 4.0f, 0.0f },
        //网格竖线
        { 0.0f, 0.0f, 0.0f },   //44
		{ 4.0f, 0.0f, 0.0f },
		{ 0.0f, 1.0f, 0.0f },
		{ 4.0f, 1.0f, 0.0f },
		{ 0.0f, 2.0f, 0.0f },
		{ 4.0f, 2.0f, 0.0f },
		{ 0.0f, 3.0f, 0.0f },
		{ 4.0f, 3.0f, 0.0f },
		{ 0.0f, 4.0f, 0.0f },
		{ 4.0f, 4.0f, 0.0f }

	};
	std::vector<float> pvalues;
	std::vector<float> dvalues;
	glm::vec4 dcolor={0.0f,0.0f,1.0f,1.0f};
	glm::vec4 ecolor={1.0f,0.0f,0.0f,1.0f};
	glm::vec4 fcolor={0.0f,1.0f,0.0f,1.0f};
	glm::vec4 gcolor={1.0f,1.0f,0.0f,1.0f};
    for(int i=0;i<sizeof(box);i++)
    {
        pvalues.push_back(box[i][0]);
        pvalues.push_back(box[i][1]);
        pvalues.push_back(box[i][2]);
        if(i<=9 or i==44 or i==45)
        {
            dvalues.push_back(dcolor[0]);
            dvalues.push_back(dcolor[1]);
            dvalues.push_back(dcolor[2]);
            dvalues.push_back(dcolor[3]);
        }else if(i<=21 or i==34 or i==35)
        {
            dvalues.push_back(ecolor[0]);
            dvalues.push_back(ecolor[1]);
            dvalues.push_back(ecolor[2]);
            dvalues.push_back(ecolor[3]);
        }else if(i<=33)
        {
            dvalues.push_back(fcolor[0]);
            dvalues.push_back(fcolor[1]);
            dvalues.push_back(fcolor[2]);
            dvalues.push_back(fcolor[3]);
        }else
        {
            dvalues.push_back(gcolor[0]);
            dvalues.push_back(gcolor[1]);
            dvalues.push_back(gcolor[2]);
            dvalues.push_back(gcolor[3]);
        }

    }
    glBindVertexArray(vao[0]);
    glBindBuffer(GL_ARRAY_BUFFER,vbo[0]);
    glBufferData(GL_ARRAY_BUFFER,pvalues.size()*4,&pvalues[0],GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER,vbo[1]);
    glBufferData(GL_ARRAY_BUFFER,dvalues.size()*4,&dvalues[0],GL_STATIC_DRAW);
    glBindVertexArray(0);
}

void LoadBuffer(void)
{
    std::vector<int> ind=mytorus.getIndices();
    std::vector<glm::vec3> vert =mytorus.getVertices();
    std::vector<glm::vec2> tex=mytorus.getTexCoords();
    std::vector<glm::vec3> norm=mytorus.getNormals();

    std::vector<float> pvalues;
    std::vector<float> tvalues;
    std::vector<float> nvalues;
    std::vector<float> dvalues;

    int numVertices=mytorus.getNumVertices();
    for(int i=0;i<numVertices;i++)
    {
        pvalues.push_back(vert[i].x);
        pvalues.push_back(vert[i].y);
        pvalues.push_back(vert[i].z);

        tvalues.push_back(tex[i].s);
        tvalues.push_back(tex[i].t);

        nvalues.push_back(norm[i].x);
        nvalues.push_back(norm[i].y);
        nvalues.push_back(norm[i].z);
        dvalues.push_back(0.0f);
        dvalues.push_back(0.0f);
        dvalues.push_back(0.0f);
        dvalues.push_back(0.0f);
    }
    glBindVertexArray(vao[1]);

    glBindBuffer(GL_ARRAY_BUFFER,vbo[2]);
    glBufferData(GL_ARRAY_BUFFER,pvalues.size()*4,&pvalues[0],GL_STATIC_DRAW);

    glBindBuffer(GL_ARRAY_BUFFER,vbo[3]);
    glBufferData(GL_ARRAY_BUFFER,tvalues.size()*4,&tvalues[0],GL_STATIC_DRAW);

    glBindBuffer(GL_ARRAY_BUFFER,vbo[4]);
    glBufferData(GL_ARRAY_BUFFER,nvalues.size()*4,&nvalues[0],GL_STATIC_DRAW);

    glBindBuffer(GL_ARRAY_BUFFER,vbo[5]);
    glBufferData(GL_ARRAY_BUFFER,dvalues.size()*4,&dvalues[0],GL_STATIC_DRAW);

    glBindBuffer(GL_ARRAY_BUFFER,ebo);
    glBufferData(GL_ARRAY_BUFFER,ind.size()*4,&ind[0],GL_STATIC_DRAW);
    glBindVertexArray(0);
}

void InitOpenGL(void)
{

    //1.0 初始化数据
    camera.camerax=2.0f;camera.cameray=1.0f;camera.cameraz=8.5f;
    camera.rotateangle=0.1f;
    mytorus.locx=0.0f;mytorus.locy=0.0f;mytorus.locz=0.0f;
    mytorus.rotateangle=0.1f;

    //1.1B 编译并使用纹理可编程管线
    renderingProgram =mycorelib.createShaderProgram("vert.glsl", "frag.glsl");
    //1.2B 选择指定的管线
    glUseProgram(renderingProgram);
    //1.3B  透视矩阵设置
    scene.projLoc=glGetUniformLocation(renderingProgram,"proj_matrix");
    scene.aspect=(float)scene.screenWidth/(float)scene.screenHeight;
    scene.pMat=glm::perspective(1.0472f,scene.aspect,0.1f,1000.0f);                 
    //1.0472radians=60degree
    glUniformMatrix4fv(scene.projLoc,1,GL_FALSE,glm::value_ptr(scene.pMat));

    glGenVertexArrays(2,vao);
    glGenBuffers(6,vbo);
    glGenBuffers(1, &ebo);
    LoadAxle();
    //1.4B
    LoadBuffer();


    //加载图片，制作纹理，贴图;除了这里加载图片外，还要在下面计算出贴图坐标，将其传到着色器里
    int width,height,nrChannels;
    glGenTextures(1, &texture);
    unsigned char *data1=stbi_load("brick.jpg",&width,&height,&nrChannels,0);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data1);
    glGenerateMipmap(GL_TEXTURE_2D);
    stbi_image_free(data1);
}

void DrawModel(float theta)
{

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
    glDepthFunc(GL_LEQUAL);

    scene.mvLoc=glGetUniformLocation(renderingProgram,"mv_matrix");
    scene.vMat=glm::translate(glm::mat4(1.0f),glm::vec3(-camera.camerax,-camera.cameray,-camera.cameraz));
    glUniformMatrix4fv(scene.mvLoc,1,GL_FALSE,glm::value_ptr(scene.vMat));

    glDisable(GL_LIGHTING);
	glDisable(GL_DEPTH_TEST);
	glColor3f(0.0f, 1.0f, 1.0f);
	glLineWidth(2.0f);

    glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
    glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(2);
    glDrawArrays(GL_LINES, 0, 54);
    glEnable(GL_LIGHTING);
	glEnable(GL_DEPTH_TEST);
    glBindVertexArray(0);

    scene.mMat=glm::translate(glm::mat4(1.0f),glm::vec3(mytorus.locx,mytorus.locy,mytorus.locz));
    scene.mMat*=glm::rotate(glm::mat4(1.0f), (float)(mytorus.rotateangle),glm::vec3(1.0f,0.0f,0.0f));
    scene.mvMat=scene.vMat*scene.mMat;
    glUniformMatrix4fv(scene.mvLoc,1,GL_FALSE,glm::value_ptr(scene.mvMat));

    //第一步，先保存原始位置到栈里
    mvStack.push(scene.mvMat);
    int mvsize=mvStack.size();

    glBindBuffer(GL_ARRAY_BUFFER, vbo[2]);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);

    glBindBuffer(GL_ARRAY_BUFFER, vbo[3]);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(1);

    glBindBuffer(GL_ARRAY_BUFFER, vbo[5]);
    glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(2);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    glDrawElements(GL_TRIANGLES, mytorus.getNumIndices(), GL_UNSIGNED_INT, 0);
    //在前面旋转的圆环的基础上，平移一个距离
    mvStack.top()*=glm::translate(glm::mat4(1.0f), glm::vec3(0.0f,1.0f,0.0f));

    glUniformMatrix4fv(scene.mvLoc,1,GL_FALSE,glm::value_ptr(mvStack.top()));
    glDrawElements(GL_TRIANGLES, mytorus.getNumIndices(), GL_UNSIGNED_INT, 0);

    mvStack.pop();
    mvsize=mvStack.size();
}

int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{

    HWND hwnd;
    HDC hDC;
    HGLRC hRC;
    MSG msg;
    BOOL bQuit = FALSE;

    if(myform.RegistWinform(hInstance)==0)
        return 0;

    /* create main window */
    hwnd = CreateWindowEx(0,"GLSample","OpenGL Sample",
                          WS_OVERLAPPEDWINDOW,
                          360,200,683,384,
                          NULL,NULL,hInstance,NULL);

    ShowWindow(hwnd, nCmdShow);

    /* enable OpenGL for the window */
    mycorelib.EnableOpenGL(hwnd, &hDC, &hRC);

    InitOpenGL();
    /* program main loop */
    while (!bQuit)
    {
        /* check for messages */
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            myform.WatchMessage(msg,&bQuit);
        }
        else
        {
            DrawModel(mytorus.rotateangle);
            SwapBuffers(hDC);
            mytorus.rotateangle += 0.01f;
            Sleep (20);
        }
    }

    /* shutdown OpenGL */
    mycorelib.DisableOpenGL(hwnd, hDC, hRC);

    /* destroy the window explicitly */
    DestroyWindow(hwnd);

    return msg.wParam;
}

上传文件用于测试效果，附件链接：

GLSL画坐标系用于显示模型位置-其他文档类资源-CSDN下载

Qt/C++编写自定义控件6-指南针仪表盘
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
04-23 1749
前言 指南针仪表盘，主要用来指示东南西北四个方位，双向对称两个指针旋转，其实就是360度打转，功能属于简单型，可能指针的绘制稍微难一点，需要计算多个点构成多边形，本系列控件文章将会连续发100+篇，一方面为了锻炼自己的毅力+坚持力，一方面为了宣传自己，如果各位对完整的源码有兴趣可以私聊，也欢迎在文章下面评论提出建议，谢谢！ 实现的功能 1:可设置当前度数 2:可设置精确度 3:可设置是否启用动画...
<3>OpenGL入门知识介绍
游戏引擎研发进阶之路
09-03 620
Opengl最大的特点莫过于坚持做到在加入新特性的同时尽量少地与旧代码发生冲突。 1.API特性 (1)数据类型 GL开头表示OpengL，函数后面使它们的最小位宽和相关描述。 注意OpenGL并没有对指针和数组做特殊的考虑，我们可以像下面这样声明一个包含10个GLshort变量的数组：GLshort shorts[10]而下面这行代码则声明了一个长度为10的指向GLdouble类型变量的指
opengl绘制坐标
03-26
C++用opengl绘制出的二维坐标，简单明了，很容易理解，并且各个部分均有注释
OpenGL 坐标系定义
weixin_33736048的博客
03-25 317
openGL使用右手坐标 从左到右，x递增 从下到上，y递增 从远到近，z递增 -------------------------------------------------------------------------------- OPENGL坐标系可分为：世界坐标系和当前绘图坐标系。 世界坐标系以屏幕中心为原点(0, 0, 0)。你面对屏幕，你的右...
OpenGL绘制三维坐标图
03-23
自制的基于MFC、OpenGL平台的三维坐标图程序，在vc2008编译通过
OpenGL画坐标轴指示图
己亥谷雨
01-05 2095
最开始是想在左下角位置画个坐标轴 后来在网上找了一个，也是别人搬运的，没有出处。学习了一下，感觉不太方便 #include <iostream> using namespace std; #include<gl/glut.h> //这个N是用来计数的，为了验证两个回调函数display和reshape谁先执行 //结果是reshape先执行 int N = 0; GLfloat transx, transy; GLfloat scale; int primw .
opengl绘制在屏幕坐标中固定位置的坐标轴模型
热门推荐
T_W_S的专栏
08-18 1万+
1，在时椎体的左下标定义为原点时：在视口发生变化时，scale=min（w，h）/pre（w，h）
GLSL画坐标系用于显示模型位置
04-05
描述 "配套我的文章‘OpenGL做一个坐标系指示方位’用于预览效果" 暗示了这个GLSL应用是与一个教程或文章相关的，该文章可能详述了如何在OpenGL中构建一个坐标轴系统，以便更好地理解和调试3D模型的位置和旋转。...
3D空间直角坐标系演示控件，使用C#和OpenTK编写
07-05
1.带有一个空间方位指针。指针指向可由方向角和俯仰角确定。 2.实现了鼠标轨迹球(ArcBall)功能。可以用鼠标拖动直角坐标系任意旋转，运行流畅，查看灵活。 目前网上关于OpenTK的中文资源很少，故在此附上源代码和...
计算机图形学及OpenGL简介摘记
hddryjv的博客
01-31 933
计算机图形学及OpenGL简介摘记
OpenGL三维坐标系绘图程序
01-11
本例实现在三维的坐标系中绘制图形，可以从COM口接收数据，并根据接收的数据在三维的坐标系中绘制图像。同时实现了把三维的曲线投影到三个平面上。
ubuntu下 qt5.5 利用opengl画3d坐标系
11-15
ubuntu16.04 下在qt 5.9.0 下采用opengl 利用glut画3维坐标系
VC2008 Opengl绘制三个坐标轴源码
02-10
VC2008 Opengl绘制三个坐标轴源码，按上下左右键可选择，帮助理解Open GL坐标。
机器视觉系列之【基础知识】-工业机器人（二）
最新发布
qq_36130719的博客
09-15 104
模型预测控制是一种基于模型的控制策略，它通过预测未来一段时间内的系统状态和控制输入，来优化当前时刻的控制输出。MPC的核心在于建立一个精确的系统模型，并利用这个模型来预测未来的行为，从而实现对系统的最优控制。
Qt OpenGL初探 - 画坐标轴
做减求空
01-13 2338
OpenGL使软件开发人员能够在CAD、内容创建、能源、娱乐、游戏开发、制造、医疗和虚拟现实等市场中创建高性能、视觉吸引力强的图形软件应用程序。`Qt OpenGL`模块可以很方便地将OpenGL应用在Qt程序中，本文使用其画了一个3D坐标轴，并详细讲解了具体的编码过程与官方手册的使用。
OpenGL画坐标系2
TiredWind的博客
11-21 3107
此项目为“OpenGL画坐标系1”的拓展，1的链接：https://blog.csdn.net/qq_37996632/article/details/103149535 思路：在原有的直线坐标轴上加上一个小的四棱锥，当然圆锥也可以，不过绘制圆锥的难度要大一点。 整体效果如下： 项目整体目录如下： 注意：对比“OpenGL画坐标系1”，修改了Coordinate.h，Coo...
openGL坐标变换
ruixj的专栏
09-06 3711
openGL坐标变换                                      坐标变换：OPENGL的每一种变换都是一个矩阵的运算。假设当前某顶点坐标为C，现在要做某种变换（设矩阵为M）得到新的坐标C1，那么运算过程就是C1＝T×C。OpenGL应用左乘规则,坐标的变换就是用变换矩阵乘以坐标向量OpenGL变换在编程的时候顺序是反过来的。想对目标 glutWireSp
绘制坐标轴
Andy20081251的专栏
08-15 1058
opengl绘制坐标轴
OpenGL画坐标系1
TiredWind的博客
11-19 5911
此项目为Qt5所写，用到的是可编程管线的现代OpenGL，通过继承Qt中的QOpenGLWidget和QOpenGLExtraFunctions实现。只是一个最简单的坐标系，三条不同颜色的直线分别代表x, y, z轴，整体效果如下： 其实实现这个坐标系在老版本的OpenGL（freeglut，glut）中是很简单的，只需几行代码，但是在可编程管线中，由于要编写着色器，复杂程度就稍微高了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

水滴与鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值