QT中学习Opengl---（坐标系统）

最新推荐文章于 2024-04-18 10:09:07 发布
最新推荐文章于 2024-04-18 10:09:07 发布
阅读量2.2k 收藏 16
点赞数 4
分类专栏： Qt之Opengl 文章标签： 学习 opengl qt 坐标 纹理
请转载请声明转载的地址
本文链接：https://blog.csdn.net/weixin_42126427/article/details/123444751
版权

前言：

本文的代码是 LearnOpenGL 中对应代码，这里提供学习，大家喜欢的可去官方网站去看看:
LearnOpenGL-CNicon-default.png?t=M276https://learnopengl-cn.readthedocs.io/zh/latest/

本章记录了，opengl中坐标系统代码，然后为了方便在qt中编写。

坐标系统：

比较重要的总共有5个不同的坐标系统：

  • 局部空间(Local Space， 或者称为物体空间(Object Space))
  • 世界空间(World Space)
  • 观察空间(View Space， 或者称为视觉空间(Eye Space))
  • 裁剪空间(Clip Space)
  • 屏幕空间(Screen Space)

     为了将坐标从一个坐标系转换到另一个坐标系， 我们需要用到几个转换矩阵， 最重要的几个
分别是模型(Model)、 视图(View)、 投影(Projection)三个矩阵。 首先， 顶点坐标开始于局部
空间(Local Space)， 称为局部坐标(Local Coordinate)， 然后经过世界坐标(WorldCoordinate)， 观察坐标(View Coordinate)， 裁剪坐标(Clip Coordinate)， 并最后以屏幕坐标(Screen Coordinate)结束。

1. 局部坐标是对象相对于局部原点的坐标； 也是对象开始的坐标。
2. 将局部坐标转换为世界坐标， 世界坐标是作为一个更大空间范围的坐标系统。 这些坐标
是相对于世界的原点的。
3. 接下来我们将世界坐标转换为观察坐标， 观察坐标是指以摄像机或观察者的角度观察的
坐标。
4. 在将坐标处理到观察空间之后， 我们需要将其投影到裁剪坐标。 裁剪坐标是处理-1.0到
1.0范围内并判断哪些顶点将会出现在屏幕上。
5. 最后， 我们需要将裁剪坐标转换为屏幕坐标， 我们将这一过程成为视口变换(Viewport
Transform)。 视口变换将位于-1.0到1.0范围的坐标转换到由 glViewport 函数所定义的坐
标范围内。 最后转换的坐标将会送到光栅器， 由光栅器将其转化为片段。

 其实我们记住：

 对应矩阵这样处理就可以。

因为绘制的立方体，需要用到深度测试，这样看上去才对。

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

绘制效果：

 代码：

顶点着色器

#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec2 aTexCoord;

out vec2 TexCoord;
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
void main()
{
        gl_Position =projection*view*model* vec4(aPos, 1.0);
        TexCoord = vec2(aTexCoord.x, aTexCoord.y);
}

 片段着色器

#version 330 core
out vec4 FragColor;

in vec2 TexCoord;

// texture samplers
uniform sampler2D texture1;
uniform sampler2D texture2;

void main()
{
        // linearly interpolate between both textures (80% container, 20% awesomeface)
        FragColor = mix(texture(texture1, TexCoord), texture(texture2, TexCoord), 0.2);
        //FragColor =texture(texture2,TexCoord);
}

头文件：

#ifndef BKQOPENGLW_H
#define BKQOPENGLW_H

#include <QOpenGLWidget>
#include <QOpenGLFunctions_3_3_Core>
#include <QOpenGLShaderProgram>
#include <QOpenGLTexture>
#include <QTimer>
class BKQOpenglW : public QOpenGLWidget, QOpenGLFunctions_3_3_Core
{
    Q_OBJECT
public:
    enum Shape{None,Rect,circle,Triangle};
    explicit BKQOpenglW(QWidget *parent = nullptr);
    ~BKQOpenglW();
    void drawShapes(Shape shape);
    void setWireFrame(bool b);
protected:
    virtual void initializeGL();
    virtual void resizeGL(int w, int h);
    virtual void paintGL();

signals:

public slots:

private:
    unsigned int VBO, VAO,EBO;
    Shape m_Shape;
    QOpenGLShaderProgram shaderProgram;
    unsigned int texture;
    QOpenGLTexture *pTexture;
    QOpenGLTexture *pTexture2;

    QTimer timer;
    int rotate{ 0 };
};

#endif // BKQOPENGLW_H

对应cpp文件：

#include "bkqopenglw.h"
#include<iostream>
#include <QDebug>
#include <QSurfaceFormat>

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

#if 0
float vertices[] = {
        // positions          // colors           // texture coords
         0.8f,  0.8f, 0.0f,   1.0f, 0.0f, 0.0f,   2.0f, 2.0f, // top right
         0.8f, -0.8f, 0.0f,   0.0f, 1.0f, 0.0f,   2.0f, 0.0f, // bottom right
        -0.8f, -0.8f, 0.0f,   0.0f, 0.0f, 1.0f,   0.0f, 0.0f, // bottom left
        -0.8f,  0.8f, 0.0f,   1.0f, 1.0f, 0.0f,   0.0f, 2.0f  // top left
    };

#endif

//顶点数据（盒子六个面，一个面两个三角）
float vertices[] = {
    -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
    0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
    0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
    0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
    -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,

    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
    0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
    0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
    0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
    -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,

    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

    0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
    0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
    0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
    0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
    0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,

    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
    0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
    0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
};


unsigned int indices[] = {  // note that we start from 0!
    0, 1, 3,  // first Triangle
    1, 2, 3   // second Triangle
};


//绘制多个盒子
static QVector3D cubePositions[] = {
    QVector3D( 0.0f,  0.0f,  0.0f),
    QVector3D( 2.0f,  5.0f, -15.0f),
    QVector3D(-1.5f, -2.2f, -2.5f),
    QVector3D(-3.8f, -2.0f, -12.3f),
    QVector3D( 2.4f, -0.4f, -3.5f),
    QVector3D(-1.7f,  3.0f, -7.5f),
    QVector3D( 1.3f, -2.0f, -2.5f),
    QVector3D( 1.5f,  2.0f, -2.5f),
    QVector3D( 1.5f,  0.2f, -1.5f),
    QVector3D(-1.3f,  1.0f, -1.5f)
};


BKQOpenglW::BKQOpenglW(QWidget *parent) : QOpenGLWidget(parent)
{
    setFocusPolicy(Qt::StrongFocus);
//    QSurfaceFormat fmt = format();
//    fmt.setRenderableType(QSurfaceFormat::OpenGL);
//    fmt.setProfile(QSurfaceFormat::CoreProfile);
    fmt.setVersion(3, 3);
//    //当启用多重采样时，将每个像素的首选样本数设置为numSamples
//    fmt.setSamples(4);
//    setFormat(fmt);


    connect(&timer,&QTimer::timeout,this,[this](){
            rotate+=2;
            if(isVisible()){
                update();
            }
        });
        timer.setInterval(50);

}

BKQOpenglW::~BKQOpenglW()
{
    makeCurrent();
    glDeleteVertexArrays(1,&VAO);
    glDeleteBuffers(1,&VBO);
    doneCurrent();
}

void BKQOpenglW::drawShapes(BKQOpenglW::Shape shape)
{
    m_Shape = shape;
    update();
}

void BKQOpenglW::setWireFrame(bool b)
{
    makeCurrent();
    if(b)
    {
       glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    }
    else {
       glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    }
    update();
    doneCurrent();
}

void BKQOpenglW::initializeGL()
{
    initializeOpenGLFunctions();

    //    shaderProgram.addShaderFromSourceCode(QOpenGLShader::Vertex,vertexShaderSource);
    //    shaderProgram.addShaderFromSourceCode(QOpenGLShader::Fragment,fragmentShaderSource);
    shaderProgram.addShaderFromSourceFile(QOpenGLShader::Vertex,":/shader/shader.vs");
    shaderProgram.addShaderFromSourceFile(QOpenGLShader::Fragment,":/shader/shader.fs");
    shaderProgram.link();
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    //绑定ebo
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(indices),indices,GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), nullptr);
    glEnableVertexAttribArray(0);

    // texture coord attribute
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);

    //绑定纹理
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
    pTexture = new QOpenGLTexture(QImage(":/images/images/brickwall.jpg").mirrored());
    pTexture2 = new QOpenGLTexture(QImage(":/images/images/awesomeface.png").mirrored());
    shaderProgram.bind();
    shaderProgram.setUniformValue("texture1",0);
    shaderProgram.setUniformValue("texture2",1);
    //默认为GL_REPEAT 重复 GL_MIRRORED_REPEAT镜像  GL_CLAMP_TO_EDGE 边缘拉伸 GL_CLAMP_TO_BORDER 超出部分使用用户定义
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_REPEAT);	// we want to repeat the awesomeface pattern so we kept it at GL_REPEAT
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_REPEAT);

    QMatrix4x4 view; //观察矩阵，后退一点
    view.translate(QVector3D(0.0f, 0.0f, -3.0f));
    shaderProgram.setUniformValue("view", view);
    QMatrix4x4 projection; //透视投影
    //坐标到达观察空间之后，我们需要将其投影到裁剪坐标。
    //裁剪坐标会被处理至-1.0到1.0的范围内，并判断哪些顶点将会出现在屏幕上
    //参数1：指定视景体的视野的角度
    //参数2：指定你的视景体的宽高比
    //参数3：指定观察者到视景体的最近的裁剪面的距离（正数）
    //参数4：指定观察者到视景体最远的裁剪面距离（正数）
    projection.perspective(45.0f, 1.0f * width() / height(), 0.1f, 100.0f);
    shaderProgram.setUniformValue("projection", projection);
    shaderProgram.release();

    timer.start();





    // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    // You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
    // VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
    glBindVertexArray(0);

}

void BKQOpenglW::resizeGL(int w, int h)
{
       glViewport(0,0,w,h);
}

void BKQOpenglW::paintGL()
{

    glEnable(GL_DEPTH_TEST);
    glClearColor(0.2f, 0.3f, 0.3f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    shaderProgram.bind();
    glBindVertexArray(VAO);
    switch (m_Shape) {
    case Triangle:
        glDrawArrays(GL_TRIANGLES,0,3);
        break;
    case Rect:
        pTexture->bind(0);
        pTexture2->bind(1);

        for (unsigned int i = 0; i < 10; i++) {
               //计算模型矩阵
               QMatrix4x4 model;
               //平移
               model.translate(cubePositions[i]);
               //这样每个箱子旋转的速度就不一样
               float angle = (i + 1.0f) * rotate;
               //旋转
               model.rotate(angle, QVector3D(1.0f, 0.3f, 0.5f));
               //传入着色器并绘制
               shaderProgram.setUniformValue("model", model);
               glDrawArrays(GL_TRIANGLES, 0, 36);
           }
        break;
    default:
        break;
    }

}

最后的话：

 每天写代码时间不多，上班时间还是比较长，写博客不易，喜欢的朋友，可以关注偶。

比卡丘不皮
关注
  • 4
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
QT绘制三维直角坐标系（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-28 723
QT绘制三维直角坐标系（附完整源码）
Qt OpenGL - 三维坐标系 (带刻度标签)
02-07
- 在OpenGL进行3D可视化，绘制网格形式的坐标系则能更清晰的展示所画图形位置。...- 在Qt OpenGL上绘制2D标签的核心思路：先确定想要绘制标签处的3D坐标，然后将其投影到2D屏幕上，最后使用QPainter进行绘制。
用qt的OpenGL绘制三维坐标系以及弧线球面，支持鼠标缩放平移旋转操作
weixin_39010374的博客
07-08 2369
如此就可以找到gl的lib库了。
Opengl es2.0 学习笔记（六）矩阵变化
weixin_30788239的博客
11-15 351
文章目录1.概述局部空间世界空间观察空间裁剪空间正射投影透视投影把它们都组合到一起2.常用矩阵3.模板code: 一.坐标系变化 openGL使用右手坐标 从左到右，x递增 从下到上，y递增 从远到近，z递增 MVP 模型矩阵(Model):将局部坐标转换为世界坐标 观察矩阵(View): 投影矩阵(Projection)：正交还是透视投影 1.概述...
Qt实现OpenGL的经典教程⑥——坐标系统
最新发布
qq_45233572的博客
04-18 1701
Qt版本：6.7操作系统：Windows10。
OpenGL with QtWidgets：屏幕坐标转世界坐标
龚建波
04-04 3097
（本文是LearnOpenGL的学习笔记，教程中文翻译地址https://learnopengl-cn.github.io/（备用地址https://learnopengl-cn.readthedocs.io/zh/latest/），写于 2022-04-04） 0.前言 在之前的图形绘制操作中，都是将模型顶点坐标转换为屏幕坐标进行显示。但在进行如人机交互时，可能需要将屏幕坐标转换到世界坐标，比如点击物体进行选中，如果采用射线拾取法，就需要将屏幕坐标系的点转到世界坐标系去。 1.知识点 先复习下顶.
QtOpenGL(一)简单的三维点
weixin_45128059的博客
06-02 1201
OpenGL网上的例子也很多，之前也一直在用，最近又系统的看了一下，也总结了一下，我我们开始吧。先绘制一些简单的三维点。
Qt+OpenGL 屏幕坐标转世界坐标
07-27
Qt + OpenGL 点云 通过Z-Buffer获取鼠标位置的深度值。然后转世界坐标。如果pointsize过大，精度会有一定损失。为1时精度在小数点后两位。当鼠标move到点上时，控制台输出原始点 x y z的坐标信息。窗口不要改动，...
opengl-qt-glm-地月系.rar
07-09
OpenGL是计算机图形学中的一种广泛应用的编程接口，用于创建2D和3D图像。它提供了丰富的函数库，允许开发者直接控制显卡进行图形...这个项目对于学习和理解OpenGL图形编程，以及Qt和glm的结合使用具有很高的参考价值。
ubuntu下 qt5.5 利用opengl画3d坐标系
11-15
在Ubuntu 16.04操作系统中，Qt 5.9.0是一个强大的跨平台应用程序开发框架，广泛用于创建图形用户界面。而OpenGL是一个开放源代码的图形库，专门用于生成2D、3D图像。在Qt中集成OpenGL，可以实现高性能的图形渲染。本...
QtOpenGL：一些Qt OpenGL演示
02-04
QtOpenGL模块是Qt库的一部分，专门用于结合OpenGL图形库，为开发者提供了在Qt环境中使用OpenGL进行高性能3D图形渲染的能力。OpenGL是一个广泛使用的开放标准，用于在各种操作系统上创建动态的2D和3D图形。 在"Qt...
Qt+OpenGL+VS2010写的输入点坐标，显示点和直线
11-23
新建一个空的Qt工程 把所给的文件添加进去即可 界面有两个部分 视图部分 点坐标输入部分 由于用的是QSpinBox类的 editingFinished 信号 所以每次输入顶点的时候不管原先那个点的值有没有变化 都要让光标在那个框中过一下 或者按个enter也行 总之要在那个框中过一下 ">新建一个空的Qt工程 把所给的文件添加进去即可 界面有两个部分 视图部分 点坐标输入部分 由于用的是QSpinBox类的 editingFinished 信号 所以每次输入顶点的时候不管原先那个点的值有没有变化 都要让光标在那个框中过 [更多]
Qt--3D中制作坐标系（5.12）
天道酬勤
12-19 3943
Qt--3D中制作坐标系（5.12）1 介绍2 思路2.1 使用CuboidMesh一类模拟坐标系3 步骤参考 1 介绍 工作中涉及，在模型中显示出坐标系出来，如下图，然后在Qt3D（scene3D）的技术路线上去找解决策略，然后发现。Qt5.12版本很尴尬，canvas3D之后版本不再支持，有些extra中的3D模块有但是不能用，因为和scene3D冲突，google半天也没合适思路，该版本该技术方向上，合适的感觉是建模型单独渲染，也可能自己研究不够深，不知道合适的策略。 2 思路 2.1 使用Cubo
【Qt】2D绘图之坐标系统
热门推荐
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师---欢迎大家一起交流(私信添加博主微信)
03-23 4万+
00. 目录 文章目录00. 目录01. 概述02. 开发环境03. Qt坐标系统04. 坐标系统变换05. 平移变换06. 缩放变换07. 扭曲变换08. 旋转变换09. 附录 01. 概述 Qt中每一个窗口都有一个坐标系统，默认的，窗口左上角为坐标原点，水平向右依次增大，水平向左依次减小，垂直向下依次增大，垂直向上依次减小。原点即为（0，0）点，以像素为单位增减。 02. 开发环境 Windows系统：Windows10 Qt版本：Qt5.15或者Qt6 03. Qt坐标系统 程序示例 void Wid
Learn OpenGL with Qt——坐标系统
ItaLink
05-08 3397
坐标系统 在上一个教程中，我们学习了如何有效地利用矩阵的变换来对所有顶点进行变换。OpenGL希望在每次顶点着色器运行后，我们可见的所有顶点都为标准化设备坐标(Normalized Device Coordinate, NDC)。也就是说，每个顶点的x，y，z坐标都应该在-1.0到1.0之间，超出这个坐标范围的顶点都将不可见。我们通常会自己设定一个坐标的范围，之后再在顶点着色器中将这些坐标变换为...
OpenGL
m0_60274660的博客
06-21 472
需要继承的两个类 #include <QOpenGLWidget> #include <QOpenGLFunctions_3_3_Core> class OpenGLWidget : public QOpenGLWidget,public QOpenGLFunctions_3_3_Core { Q_OBJECT public: explicit OpenGLWidget(QWidget *parent = nullptr); virtual void i
QT学习（17）：QT中OpenGL的简单使用
qq_45088122的博客
11-14 2023
0,1,3对应顶点数组中第一行、第二行、第四行，为一个三角形，1，2，3同理，两个三角形即一个矩形。顶点数组vertices：四个顶点数据，每一行对应一个顶点，有八个float数值，分别为坐标（3），颜色（3），纹理（2）。：加工顶点数据，把顶点坐标进行平移、旋转、缩放等各种变换操作，修改各种顶点数据，比如纹理坐标，法向量等。VBO，Vertex Buffer Objects顶点缓冲区，一个元素对应一个顶点数据。0、顶点数据：CPU将顶点数据传入GPU，包括顶点的坐标、颜色、法向量、纹理坐标等。
学习OpenGL（三）：QOpenGLShaderProgram的使用
weixin_42219627的博客
07-31 1736
QtOpenGL界面交互Demo
【OpenGL学习笔记六】使用QOpenGLShaderProgram编写着色器程序
briant_ccj的专栏
01-13 888
z​​​基于Qt的OpenGL(三)：QOpenGLShaderProgram和GLSL 在编写着色器程序的时候如果不使用QOpenGLShaderProgram，那么程序写起来将是这样的 static const char* vertexShaderSource = "#version 330 \n" "layout(location = 0) in vec3 posVertex;\n" "void main() {\n" "
qt中利用opengl显示三维模型步骤
04-28
在Qt中使用OpenGL显示三维模型的步骤如下： 1. 创建一个Qt窗口并设置为OpenGL视口。 2. 初始化OpenGL，包括设置视口大小、清除颜色和深度缓冲区等。 3. 加载三维模型数据，例如顶点坐标、法线、纹理坐标等。 4. 编写着色器程序，包括顶点着色器和片段着色器。 5. 将三维模型数据传输到GPU中，例如顶点缓冲区和纹理缓冲区等。 6. 在绘制循环中，调用OpenGL函数绘制三维模型，例如glDrawArrays和glDrawElements等。 7. 在每次绘制循环结束后，调用Qt函数swapBuffers刷新窗口。 需要注意的是，OpenGL的使用需要一定的数学和物理知识，例如矩阵变换、光照模型和纹理映射等。在实际开发中，可以使用现成的OpenGL库或者OpenGL框架，例如Assimp、GLEW和QtOpenGL等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值