OpenGL做一个坐标系指示方位

已于 2022-04-05 17:33:03 修改
阅读量2.3k 收藏 23
点赞数 5
分类专栏： 笔记 文章标签： 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下载

水滴与鱼
关注
  • 5
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
opengl.rar_OpenGL 坐标系_Transformations
09-21
详解OpenGL的坐标系、投影和几何变换
D50.1.0 如何使用OpenGL绘制三维坐标系
思考思考再思考
07-31 2844
如何在屏幕左下角绘制直角坐标系？ 第一步，指定屏幕绘制区域 第二步，设定投影效果、观察坐标及旋转缩放等 第三步，绘制坐标轴，绘制箭头 第四步，添加“xyz”字符 ​ ​ 第一，图中圆环所在的指定区域与坐标轴所在的区域是两个相互独立的空间，通过使用glViewport函数限定。 glViewport(0,0,500,500);//指定圆环绘制空间，从(0,0)位置开始，长宽...
利用OpenGL在窗口上绘制出三维坐标
Carnnation的专栏
03-11 1万+
/*今天刚开通CSDN博客，以此记录我的编程学习之旅*/ 按时间顺序来讲，这是计算机图形学课程的第一个编程实践，大概是在一年前吧。这个程序是在nehe OpenGL框架下完成的，现在回头来看，这是一个很基础、很简单的小程序，但可以说是我编写（改编）的第一个图形窗口程序。 下面是程序绘制三维坐标的主体代码： int DrawGLScene(GLvoid) // 这个自定义函数用于完成窗口场景绘
Qt OpenGL初探 - 画坐标轴
das白的博客
01-13 1218
OpenGL使软件开发人员能够在CAD、内容创建、能源、娱乐、游戏开发、制造、医疗和虚拟现实等市场中创建高性能、视觉吸引力强的图形软件应用程序。`Qt OpenGL`模块可以很方便地将OpenGL应用在Qt程序中，本文使用其画了一个3D坐标轴，并详细讲解了具体的编码过程与官方手册的使用。
【OpenGL】02 - OpenGL中的坐标系
热门推荐
ronintao的专栏
06-30 1万+
【目标】：学习OpenGL中的坐标系统。   【参考】： 1、《计算机图形学(OpenGL版) （第三版）》 Francis著 （本文主要涉及第三章~第七章） 2、《计算机图形学(OpenGL版) （第三版）》 Donald著   一、前言         坐标系应该是任何图像系统的基石。在学习Cocos2D的过程中，对着《权威指南》上草草结束的坐标系介绍，实在是看的一头雾水，找了本
5个OpenGL开发必须了解的坐标系
新缸中之脑
07-22 222
OpenGL 期望在每个顶点着色器运行后，我们希望变得可见的所有顶点都处于标准化设备坐标中。即每个顶点的x、y、z坐标应在-1.0到1.0之间；在此范围之外的坐标将不可见。我们通常做的是指定我们自己确定的范围（或空间）中的坐标，并在顶点着色器中将这些坐标转换为标准化设备坐标（NDC）。然后将这些 NDC 提供给光栅化器，将其转换为屏幕上的 2D 坐标/像素。推荐：用快速搭建可编程3D场景。将坐标转换为 NDC 通常是逐步完成的，我们将对象的顶点转换为多个坐标系，然后最终将它们转换为 NDC。
用qt的OpenGL绘制三维坐标系以及弧线球面，支持鼠标缩放平移旋转操作
weixin_39010374的博客
07-08 1965
如此就可以找到gl的lib库了。
OpenGL绘图初识总结与简单操作——画线与设置透明度
weixin_46568899的博客
02-16 2495
OpenGL绘图初识总结与简单操作——画线与设置透明度
Qt OpenGL(三十三)——Qt OpenGL 核心模式-绘制三维坐标系
ifeng12358的博客
01-31 2972
在平常的项目中，我们会遇到在界面绘制的时候，展示坐标系的需求。本篇介绍三维坐标系的绘制方法。本文原创作者：冯一川（[email protected]），未经作者授权同意，请勿转载。在绘制三维坐标系的时候，可以由三个XYZ坐标轴加上各个坐标轴顶部的棱锥组成。
dikaer.rar_OpenGL 坐标系
09-24
此程序是给予OpenGL的笛卡尔坐标系的空间的建立，充分理解笛卡尔坐标系。
ubuntu下 qt5.5 利用opengl画3d坐标系
11-15
ubuntu16.04 下在qt 5.9.0 下采用opengl 利用glut画3维坐标系
OpenGL坐标系讲解
12-17
非常系统的讲解关于使用OpenGL进行编程中，关于坐标系的介绍，是做工业建模、三维建模等不可少的资料，欢迎大家使用。
MyMDOpenGL.rar_opengl_opengl 坐标系_三维 旋转
09-22
一个用基于opengl的三维坐标系通过鼠标的动作　我们可以实现鼠标的旋转
笨蛋学C++【C++基础第六弹】
YSL_Monet的博客
04-24 899
定义类需要用到关键字 class，然后指定类的名称，类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数class 类名{访问修饰符（public/protected/private）:成员变量;成员函数();
C语言案例——输出 Fibonacci 数列（斐波那契数列）的前 40 项
悟道子HD
04-25 484
输出 Fibonacci 数列（斐波那契数列）的前 40 项 #include void main() { int a[40]= {1,1}; int i; printf( "%12d%12d",a[0],a[1]); for(i=2; i
C++ Primer (第五版）第八章习题部分答案
最新发布
weixin_48467622的博客
04-27 984
C++ Primer (第五版）第八章习题部分答案
CSAPP | Lab2-Bomb Lab详细解析
wangs29的博客
04-24 1269
邪恶的邪恶博士在我们班的机器上安放了大量的“二元炸弹”。二进制炸弹是一个由一系列阶段组成的程序。每个阶段都要求你在 stdin 上键入一个特定的字符串。如果你键入了正确的字符串，那么这个阶段就会被拆除，炸弹就会进入下一个阶段。否则，炸弹会通过打印“ BOOM 然后终止。当每个阶段都被拆除时，炸弹就会被拆除。我们要处理的炸弹太多了，所以我们给每个学生一个炸弹去拆除。你们的任务，你们别无选择，只能接受，就是在due date前拆除炸弹。祝你好运，欢迎加入拆弹小组！
手搓顺序表（C语言）
m0_62646213的博客
04-23 667
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
c入门基础题（3）
梦昼初
04-26 853
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
opengl绘制三维坐标系
05-18
要使用OpenGL绘制三维坐标系，需要进行以下步骤： 1. 首先，需要设置OpenGL的视口和投影矩阵，以确保正确的视角和透视效果。这可以通过glViewport和gluPerspective函数来实现。 2. 接下来，需要定义三个向量表示坐标系的三个轴，通常是X轴，Y轴和Z轴。 3. 然后，可以使用OpenGL的绘图函数（如glBegin和glEnd）来绘制每个轴线。对于每个轴线，需要先设置颜色，然后使用glVertex3f指定起点和终点。 以下是一个基本的OpenGL代码示例，用于绘制一个简单的三维坐标系： ``` void drawAxes() { // 设置视口和投影矩阵 glViewport(0, 0, windowWidth, windowHeight); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45.0, (double)windowWidth / (double)windowHeight, 0.1, 100.0); // 定义坐标系三个轴的向量 vec3 xAxis = vec3(1, 0, 0); vec3 yAxis = vec3(0, 1, 0); vec3 zAxis = vec3(0, 0, 1); // 绘制X轴 glColor3f(1.0, 0.0, 0.0); glBegin(GL_LINES); glVertex3f(0.0, 0.0, 0.0); glVertex3f(1.0, 0.0, 0.0); glEnd(); // 绘制Y轴 glColor3f(0.0, 1.0, 0.0); glBegin(GL_LINES); glVertex3f(0.0, 0.0, 0.0); glVertex3f(0.0, 1.0, 0.0); glEnd(); // 绘制Z轴 glColor3f(0.0, 0.0, 1.0); glBegin(GL_LINES); glVertex3f(0.0, 0.0, 0.0); glVertex3f(0.0, 0.0, 1.0); glEnd(); } ``` 这段代码包含一个名为“drawAxes”的函数，该函数在OpenGL窗口中绘制了一个三维坐标系。注意，这只是一个基本示例，您可以根据需要自定义颜色，坐标轴的长度和粗细等参数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

水滴与鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值