OPENGL VAO VBO使用步骤

合集下载

opengl入门教程

opengl入门教程OpenGL入门教程OpenGL是一种跨平台的图形库，可用于创建各种类型的图形和视觉效果。

本教程将带你入门使用OpenGL，并介绍一些基本的概念和技术。

安装OpenGL首先，你需要安装OpenGL的开发环境。

具体安装方法将因操作系统而异，以下是一些常见操作系统的安装指南。

- Windows: 在Windows上，你可以使用MinGW或者MSYS2安装OpenGL。

- macOS: OpenGL在macOS上是默认安装的，你只需要确保你的系统版本满足OpenGL的要求。

- Linux: 在Linux上，你可以使用包管理器安装OpenGL的开发环境，如apt-get (Ubuntu)或yum (Fedora)。

创建一个OpenGL窗口在开始编写OpenGL应用程序之前，你需要创建一个OpenGL 窗口来显示你的图形。

以下是使用GLUT创建一个简单窗口的例子。

```c++#include <GL/glut.h>void display() {glClear(GL_COLOR_BUFFER_BIT);glBegin(GL_TRIANGLES);glVertex2f(-0.5, -0.5);glVertex2f(0.5, -0.5);glVertex2f(0.0, 0.5);glEnd();glFlush();}int main(int argc, char** argv) {glutInit(&argc, argv);glutCreateWindow("OpenGL Window");glutDisplayFunc(display);glutMainLoop();return 0;}```运行上述代码，你将看到一个简单的OpenGL窗口中显示了一个三角形。

绘制基本图形OpenGL提供了一组基本的绘图函数，可用于绘制各种类型的图形。

以下是一些常见的绘图函数：- `glBegin(GL_POINTS)`: 用于绘制点。

opengl使用手册简书

OpenGL（Open Graphics Library）是一种用于渲染2D和3D图形的跨平台图形API。

OpenGL提供了一系列的函数，可以用来配置图形环境、绘制几何图形、处理纹理、执行变换等。

以下是一个简要的OpenGL使用手册的概述：1. 初始化OpenGL环境：-创建OpenGL上下文，配置窗口和视口，初始化OpenGL的各种参数。

2. 设置投影和视图矩阵：-使用OpenGL的矩阵操作函数，设置投影矩阵和视图矩阵，定义场景中物体的可见范围和视图。

3. 创建和加载着色器：-编写顶点着色器和片元着色器，将它们编译成着色器程序，并链接到OpenGL上下文。

4. 创建和绑定缓冲区对象：-创建顶点缓冲对象（VBO）和索引缓冲对象（IBO）来存储顶点数据和索引数据。

5. 定义顶点数据和绘制图形：-定义顶点数据，将数据传递到缓冲区对象中，使用OpenGL函数绘制图形。

6. 处理纹理：-加载纹理图像，创建纹理对象，将纹理数据传递到GPU，使用纹理进行图形渲染。

7. 执行变换：-使用OpenGL的矩阵操作函数，对物体进行平移、旋转、缩放等变换。

8. 设置光照和材质：-配置光源和材质属性，实现光照效果。

9. 深度测试和遮挡剔除：-启用深度测试和遮挡剔除，以处理物体的深度关系和遮挡关系。

10. 处理用户输入：-处理用户输入，例如键盘和鼠标事件，以交互式地改变场景。

11. 错误处理：-添加错误检查，确保OpenGL函数的调用没有错误，方便调试。

12. 清理和释放资源：-在程序结束时清理和释放分配的OpenGL资源，防止内存泄漏。

13. OpenGL扩展：-了解和使用OpenGL的扩展，以获取更先进的图形特性。

14. 学习资源：-利用OpenGL的学习资源，包括在线教程、书籍和社区，以深入了解图形编程。

请注意，上述步骤是一个简要的概述。

OpenGL是一个庞大而灵活的库，涵盖了广泛的图形编程概念。

深入学习OpenGL需要时间和实践。

OPENGL怎么用

[OPENGL怎么用]OPENGL编程类似C编程，实际接口就是C，所以熟悉C是必要的一般编程可用到的函数库包括：OPENGL实用库：函数以glu开头OPENGL辅助库：函数以aux开头Windows专用函数库：函数以wgl开头Win32API：无专用前缀OPENGL中有115个核心函数，可以在任何OPENGL平台上使用OPENGL实用库比上面这115个函数高一级，提供高级调用OPENGL辅助库本来是提供初学者入门的函数，不保证在任何平台的使用但恰好可以在WIN32下使用，所以本讲座将大量引用WIN32下OPENGL编程有两个方便途径：1使用辅助库2使用C++基于消息驱动的编程显然1要简单一些，入门从这里开始吧。

[用之前的准备]1首先你需要下列*.lib包含在你的工程中：opengl32.lib glu32.lib glaux.lib本讲座所有例子“将”在VC5下调试通过，所以从project->setting->link->general->object/libary modules中加入上面三个*.lib（这些LIB，VC4以上版本已经自带，加入即可，不用在四处搜寻文件）2另外在你的运行程序路径下或\win95\system\下你需要一些*.dll动态连接库opengl32.dll glu32.dll rxddi.dll mga.drv第一讲[编程入门]这里我将给出一个小例子让大家熟悉用辅助库的编程结构：// GLOS.H//////////////////////////////////////////////////////////// This is an OS specific header file//判别操作系统的基本头文件#include <windows.h>// disable data conversion warnings#pragma warning(disable : 4244) // MIPS#pragma warning(disable : 4136) // X86#pragma warning(disable : 4051) // ALPHA////////////////////////////////////////////////////////////opengl.cpp//主程序#include "glos.h"#include <GL/gl.h>#include <GL/glaux.h>#include "windows.h"void main(void){/*初始化：*/auxInitDisplayMode(AUX_SINGLE|AUX_RGBA);//窗口显示单缓存和RGB（彩色）模式auxInitPosition(0,0,500,500);//大小x=500 y=500 （0，0）是屏幕左上点auxInitWindow("sample1");//窗口初始化，参数是标题glClearColor(0.0,0.0,0.0,0.0);//将窗口清为黑色glClear(GL_COLOR_BUFFER_BIT);//将颜色缓存清为glClearColor命令所设置的颜色//即背景色/*绘图*/glColor3f(1.0,0.0,0.0);//选颜色（R，G，B），参数0<x<1，这里就是红色glRectf(-0.5,-0.5,0.5,0.5);//画个方块glFlush();//强制绘图，不驻留缓存_sleep(1000);//windows函数，显示1秒（单位是毫秒）}//end of sample根据注释，应该看出程序功能：显示红色方块（2D）一秒钟。

vbo协议的介绍

vbo协议的介绍VBO协议（Vertex Buffer Objects）是一种OpenGL的扩展规范，用于将数据从客户端存储区域移动到图形卡存储区域，提高处理速度。

1.VBO的作用VBO可以将常用的数据资料存放于显示卡的显存上，这样显示卡GPU能快速获得数据，从而提高处理速度。

它不需要从本已不堪重负的系统内存中频繁传送资料，减轻了系统内存的负担，提高了整体系统的运行效率。

此外，使显示卡能快速获得渲染画面所需要的各项数据，以此达到更佳的绘图效能。

2.VBO的使用在OpenGL中，可以通过以下步骤使用VBO：首先，禁用顶点数组和法线数组（glDisableClientState(GL_NORMAL_ARRAY)；glDisableClientState(GL_VERTEX_ARRAY)），然后解除绑定（glBindBuffer(GL_ARRAY_BUFFER, 0)）。

如果想更新VBO中的数据，可以通过以下三种方式：重新对VBO对象进行绑定，用glBufferData把新数据交给VBO；使用glBufferSubData只更新VBO中部分数据；使用glMapBuffer -glUnMapBuffer将数据全传回来再传过去。

3.VBO的优缺点使用VBO的优点在于，它能将数据存储在显存中，减轻系统内存的负担，提高处理速度。

同时，它也能使显示卡快速获取渲染所需的数据，提高绘图效能。

然而，VBO也存在一些缺点。

例如，它要求更多的步骤和更复杂的编程模型，增加了开发复杂性。

另外，尽管使用VBO可以降低内存使用和提高了处理速度，但这也需要更多的硬件和软件的配合和支持。

4.VBO的应用在使用OpenGL进行3D渲染时，可以使用VBO来优化性能。

例如，在游戏或科学可视化程序中，需要频繁地绘制大量的3D对象，这时候使用VBO可以显著提高渲染效率。

此外，对于一些需要处理大量顶点数据的场景，如复杂的3D模型、高分辨率图像等，使用VBO也能提供更好的性能。

使用OpenGL VBO扩展

使用OpenGL VBO扩展－－Nehe教程开发者在线更新时间:2008-07-03作者：huawenguang来源:PhysDev论坛本文关键词：NeheOpenGL VBOGPU任何一个3D应用程序的最大的目标之一就是速度，你需要自始至终的限制实际渲染的三角形数目，不管你是采用排序，剔除(Culling)，还是层次细节(LOD)。

如果其它的方法都无效了，你想简单提高多边形的提交速度的话，通常可以利用OpenGL提供的优化方法，顶点数组是一个比较好的方法。

加上最近一个名称为Vertex Buffer Object的扩展，这大大提高了应用的FPS。

ARB_Vertex_Buffer的扩展工作的和顶点数组很像，除了一点，那就是ARB_Vertx_Buffer把数据加载到显卡的高性能的显存里。

大大降低了渲染时间。

当然，这个扩展是依赖较新的硬件的，不是所有的图形卡都支持的，所以我们必须使用一些技术来进行平衡。

在这个教程里，我们将要：1：从高度图里加载数据。

2: 使用顶点数组更加有效的把网格数据提交给OpenGL。

3: 通过VBO（Vertex_Buffer_Object)把数据加载到高性能的显存里。

现在我们来定义几个应用程序的参数。

代码:#define MESH_RESOLUTION 4.0f // 每个顶点对应几个像素#define MESH_HEIGHTSCALE 1.0f // Mesh Height Scale//#define NO_VBOS // 如果定义了，强制的不使用VBO开头这两个参数是为高度图定义的。

第一个定义了高度图里每一个像素的分辨率。

后面一个设定了加载了高度图数据后在垂直方向需要进行的缩放比例。

第三个常量，如果你定义了的话，将强行不使用VBO。

下一步，我们将定义VBO 扩展的常量，数据类型，和函数指针。

代码://VBO扩展的定义，从glext.h摘抄#define GL_ARRAY_BUFFER_ARB 0x8892#define GL_STATIC_DRAW_ARB 0x88E4typedef void (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer); typedef void (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);typedef void (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers); typedef void (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);// VBO 扩展的函数指针PFNGLGENBUFFERSARBPROC glGenBuffersARB = NULL; // VBO 名字生成函数PFNGLBINDBUFFERARBPROC glBindBufferARB = NULL; // VBO 绑定函数PFNGLBUFFERDATAARBPROC glBufferDataARB = NULL; // VBO 数据加载函数PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = NULL; // VBO 删除函数我只是包含了这个演示程序所需要的东西次。

android OpenGL ES 笔记 3-VBO的使用步骤

Vertex Buffer Objects(VBOs)是一组保存在显存中的数据，这些数据可以是顶点，顶点颜色，顶点法线，顶点索引或贴图坐标等等。

由于这些数据都是保存在显存中的，而且可以随时修改数据或整块替换数据，这样就极大的提高了显卡的工作效率和渲染的速度。

VBO的概念类似于D3D中的顶点缓冲和索引缓冲的概念。

这篇文章将通过实际的例子来说明在openGL中如何使用VBOs，并且和使用传统的glVertex()函数定义顶点和使用glCallList()函数进行比较。

现在要渲染一个模型，首先定义该模型的顶点数组。

struct myVertex{GLfloat x,y,z; // vertexGLfloat nx,ny,nz; // noraml};这里定义了一个结构体数据，包括顶点和法线，它们都是浮点型的，所以该结构体一共占用4*6=24字节的空间。

有了顶点结构体后，为了提供顶点间连接的信息，我们还需要定义索引数组。

myVertex *vertexData;GLuint*indexData;这里使用无符号的整型定义了一个定点数组的指针，myVertex *vertexData 是用我们定义的顶点结构体定义了一个顶点数据指针。

在使用VBO之前，我们先将数据初始化到顶点数组和索引数组中。

假设现在顶点数据和索引数组都有数据，现在就可以使用VBO了。

使用VBO和使用其他openGL的一些对象差不多，使用前都要先申请和创建。

使用VBO也要先创建对象。

GLuint BufferName[2];glGenBuffers(2, BufferName);为了将顶点数据和索引数据能放到对应的缓存中，这里定义了一个保存两个缓存id的BufferName数组。

然后使用glGenBuffers()函数申请2个缓存id。

申请到id 后立即为要使用的缓存分配空间和初始化。

glBindBuffer(GL_ARRAY_BUFFER, BufferName[0]);glBufferData(GL_ARRAY_BUFFER, vertexSize, vertexData, GL_STATIC_DRAW);glVertexPointer(3, GL_FLOAT,24,0);glNormalPointer(GL_FLOAT, 24, (GLvoid*)12);上面的代码中，glBindBuffer表示绑定一个要使用的buffer对象，该函数有2个参数，该函数的原型为void glBindBuffer(GLenum target, GLuint buffer);参数target表示buffer的类型，参数buffer表示id。

OpenGL渲染流程

OpenGL渲染流程⼀.什么是openGLOpenGL被定义为“图形硬件的⼀种软件接⼝”。

从本质上说，它是⼀个3D图形和模型库，具有⾼度的可移植性，具有⾮常快的速度。

⼆.管线管线这个术语描述了opengl渲染的整个过程。

openGL采⽤cs模型：c是cpu，s是GPU，c给s的输⼊是vertex信息和Texture信息，s的输出是显⽰器上显⽰的图像。

下⾯这2个图⽐较清楚的讲解了opengl的渲染管线。

相信没有opengl基础的应该看不懂，下⾯会简单的介绍这个流程，再看下⽂之前，建议先看，对理解opengl⼯作原理绝对有帮助。

三.管线详解下⾯这个图取⾃《OpenGL ES 3.0编程指南》，此流程为可编程管线。

1.VBO/VAO（顶点缓冲区对象或顶点数组对象）:VBO/VAO（到底是啥，下回讲解）是cpu提供给GPU的顶点信息，包括了顶点的位置、颜⾊（只是顶点的颜⾊，和纹理的颜⾊⽆关）、纹理坐标（⽤于纹理贴图）等顶点信息。

2.VertexShader（顶点着⾊器）：顶点着⾊器是处理VBO/VAO提供的顶点信息的程序。

VBO/VAO提供的每个顶点都执⾏⼀遍顶点着⾊器。

Uniforms（⼀种变量类型）在每个顶点保持⼀致，Attribute每个顶点都不同（可以理解为输⼊顶点属性）。

执⾏⼀次VertexShader输出⼀个Varying和gl_positon。

3.PrimitiveAssembly（图元装配）：顶点着⾊器下⼀个阶段是图元装配，图元（prmitive）是三⾓形、直线或者点精灵等⼏何对象。

这个阶段，把顶点着⾊器输出的顶点组合成图元。

4.rasterization（光栅化）：光栅化是将图元转化为⼀组⼆维⽚段的过程，然后，这些⽚段由⽚段着⾊器处理（⽚段着⾊器的输⼊）。

这些⼆维⽚段代表着可在屏幕上绘制的像素。

⽤于从分配给每个图元顶点的顶点着⾊器输出⽣成每个⽚段值的机制称作插值（Interpolation）。

现代 OpenGL 教程 01 - 入门指南说明书

现代OpenGL教程 01——入门指南欢迎大家，这是现代OpenGL教程系列的第一篇。

所有代码都是开源的，你可以在GitHub上下载：https:///tomdalling/opengl-series 通过这篇教程，你将会学到如何在Windows下用Visual Studio 2013或Mac下用Xcode搭建OpenGL 3.2工程。

该应用包含一个顶点着色器（vertex shader），一个片段着色器（fragment shader）和使用VAO和VBO来绘制的三角形。

该工程使用GLEW来访问OpenGL API，用GLFW来处理窗口创建和输入，还有使用GLM进行矩阵/矢量相关的数学运算。

这听上去有点无聊，但搭建这样的工程确实挺麻烦的，尤其对于初学者。

只要解决完这问题，我们就可以开始玩些有趣的东西了。

[TOC]获取代码所有例子代码的zip打包可以从这里获取：https:///tomdalling/opengl-series/archive/master.zip。

这一系列文章中所使用的代码都存放在：https:///tomdalling/opengl-series。

你可以在页面中下载zip，加入你会git的话，也可以复制该仓库。

本文代码你可以在source/01_project_skeleton目录里找到。

使用OS X系统的，可以打开根目录里的opengl-series.xcodeproj，选择本文工程。

使用Windows系统的，可以在Visual Studio 2013里打开opengl-series.sln，选择相应工程。

工程里已包含所有依赖，所以你不需要再安装或者配置额外的东西。

如果有任何编译或运行上的问题，请联系我。

关于兼容性的提醒本文使用OpenGL 3.2，但我会尝试保持如下兼容：向后兼容OpenGL 2.1向前兼容OpenGL 3.X和4.X兼容Android和iOS的OpenGL ES 2.0因为OpenGL和GLSL存在许多不同版本，本文代码不一定能做到100%上述兼容。

OpenGL中VA,VAO,VBO和EBO的区别

OpenGL中VA,VAO,VBO和EBO的区别1，顶点数组(Vertex Array) VA，顶点数组也是收集好所有的顶点，⼀次性发送给GPU。

不过数据不是存储于GPU中的，绘制速度上没有显⽰列表快，优点是可以修改数据。

4.VBO（Vertex Buffer Object）顶点缓冲区对象 VBO，全称为Vertex Buffer Object，与FBO，PBO并称，但它实际上⽼不少。

就某种意义来说，他就是VA（Vertex Array）的升级版。

通过顶点缓冲对象(Vertex Buffer Objects, VBO)管理这个内存，它会在GPU内存（通常被称为显存）中储存⼤量顶点。

使⽤这些缓冲对象的好处是我们可以⼀次性的发送⼀⼤批数据到显卡上，⽽不是每个顶点发送⼀次。

5.VAO（Vertex Array Object）顶点数组对象 VAO的全名是Vertex Array Object，⾸先，它不是Buffer-Object，所以不⽤作存储数据；其次，它针对“顶点”⽽⾔，也就是说它跟“顶点的绘制”息息相关。

（VAO和VA没有任何关系） VAO)可以像顶点缓冲对象那样被绑定，任何随后的顶点属性调⽤都会储存在这个VAO中。

这样的好处就是，当配置顶点属性指针时，你只需要将那些调⽤执⾏⼀次，之后再绘制物体的时候只需要绑定相应的VAO就⾏了。

这使在不同顶点数据和属性配置之间切换变得⾮常简单，只需要绑定不同的VAO就⾏了。

OpenGL的核⼼模式要求我们使⽤VAO，所以它知道该如何处理我们的顶点输⼊。

5.EBO（Element Buffer Object）索引缓冲对象在渲染顶点这⼀话题上我们还有最有⼀个需要讨论的东西——索引缓冲对象(Element Buffer Object，EBO，也叫Index Buffer Object，IBO)。

和顶点缓冲对象⼀样，EBO也是⼀个缓冲，它专门储存索引，OpenGL调⽤这些顶点的索引来决定该绘制哪个顶点。

VBO软件操作手册

1.硬件 (4)1.1硬件` (4)1.2新手上路 (5)1.3LED 解释 (7)1.4电池 (7)1.5连接图 (8)1.6蜂鸣器声音 (10)2.使用技巧 (11)3.操作手则 (12)4.设置 VBOX (15)VBOX安装 (15)4.2Misc Channels其它通道 (16)4.4设置 (17)4.5Info (19)5.软件—新手上路 (20)5.1怎样做加速试验 (20)5.2怎样做制动实验 (20)5.3怎样通过图形化的界面查看测试结果 (20)5.5怎样在没有手提计算机连接的情况下进行试验 (21)6.软件–开始使用 (22)6.1主屏幕 (22)6.1.1用户设置前面板 (23)7.软件主菜单 (24)7.1File 文件 (24)7.1.1File load 文件载入 (24)7.1.2File save 文件保存 (24)7.1.3Replay file 文件回放 (24)7.1.4Repair/expand file 修补/扩充文件 (24)7.1.5Language语言 (24)7.2Options 选项 (24)7.2.1Unit of measurement测量单位 (24)7.2.2GPS cold start GPS 冷启动 (24)7.2.3 com口选择 (25)7.2.4Lock results until manually reset锁定结果直到手动复位 (25)7.2.5VBOX II & Pro Rev 4 (25)7.2.6 Measure distance using external trigger 使用外部触发器测量距离 (25)7.2.7Accel table columns 加速表纵列 (26)7.2.8Reset time when stationary 停止时把时间复位 (26)7.2.9Enable Slip angle calculations on Yaw sensor data 允许在偏航传感器数据上进行偏离角计算 (26)7.2.10Show Real Time Scope 显示实时范围 (26)7.2.11Put radius of turn in channel data 把转弯半径放到通道数据中 (26)7.2.12Delimiter for text files 文本文件的分隔符 (26)7.2.13Use target speed 1 for MFDD 使用的目标速度给MFDD (26)7.3Target speeds 目标速度 (26)7.3.1Test range 1 试验范围1 (26)7.3.2Test range 2试验范围2 (26)7.3.30 to 100 to 0 range 零到100到零范围 (27)7.4Real time plot 实时绘图 (27)7.5Select Run 选择运行 (28)7.5.1Default setups 缺省设置 (29)7.5.2Manual setup 手动设置 (31)7.6VBOX Setup VBOX 设置 (31)7.7Graph 图形 (31)7.8Start Finish 起点终点 (31)7.8.1Load start finish line and splits载入起/终点线和分离位置 (31)7.8.2Save start/finish line and splits保存起/终点线和分离位置 (32)7.8.3Start finish line length起/终点线的长度 (32)7.8.4Start finish line tolerance起终点线的公差 (32)7.8.5Accumulative split times 累计分离时间 (32)7.9.1Enable log file creation 允许记录文件产生 (32)7.9.2Include MFDD in logfile 在记录文件中包括MFDD (32)7.9.3Include test range 2 in logfile 在记录文件中包括试验范围2 (32)7.10Help 帮助 (32)8.GRAPH图形 (33)8.1概述 (33)8.2选择通道 (34)8.3设置外部输入信号的比例大小 (35)8.4键盘和鼠标指令 (36)8.5快捷键 (36)8.6定义起点/终点线和分离点。

CSharpGL创建和使用VBO的最佳方式

CSharpGL创建和使用VBO的最佳方式近日在OpenGL红宝书上看到这样的讲解。

其核心意思是，在创建VBO时用glBufferData(GL_ARRAY_BUFFER, length, NULL, GL_STATIC_DRAW);来初始化buffer占用的内存（此内存在GPU端），其中的NULL 表示并未初始化数据（即此buffer中的数据是随机值，类似在C语言中刚刚创建一个数组int x[10]; 的情况）。

这样，就不必在CPU端申请大量内存了。

接下来需要初始化buffer数据时，用复制代码1 IntPtr pointer = buffer.MapBuffer(MapBufferAccess.WriteOnly);2 var array = (vec3*)pointer.ToPointer();3 for (int i = 0; i < length; i++)4 {5 array[i] = this.model.positions[i];6 }7 ptr.UnmapBuffer();复制代码来直接操作GPU上的数据即可。

使用这种方式，省去了在CPU端创建大规模非托管数组并上传到GPU端的步骤，直接在GPU 端创建了buffer，且所需代码更少，可以说是目前我找到的最佳方式。

因此我在CSharpGL中集成并使用了这种方式。

回到顶部(go to top)顶点属性bufferCSharpGL中，用于描述顶点属性数组（Vertex Buffer Object）的类型是VertexAttributeBufferPtr 。

以前，我们可以通过如下的方式创建VertexAttributeBufferPtr 。

复制代码1 // 先在CPU端创建非托管数组VertexAttributeBuffer<vec3>对象2 using (var buffer = new VertexAttributeBuffer<vec3>(3 varNameInShader, VertexAttributeConfig.Vec3, BufferUsage.StaticDraw))4 {5 buffer.Alloc(this.model.positions.Length);// 在CPU端申请内存6 unsafe// 使用指针快速初始化7 {8 var array = (vec3*)buffer.Header.ToPointer();9 for (int i = 0; i < this.model.positions.Length; i++)10 {11 array[i] = this.model.positions[i];12 }13 }14 // 将CPU端的VertexAttributeBuffer<vec3>上传到GPU，获得我们需要的buffer 对象。

opengl使用手册简书

opengl使用手册简书【实用版】目录一、OpenGL 简介二、OpenGL 函数库1.核心函数库2.矩阵操作、几何变换和投影变换函数3.扩展库 GLEW三、OpenGL 菜单的使用1.交互式输入设备的处理2.glut 命令与鼠标函数四、总结正文一、OpenGL 简介OpenGL（Open Graphics Library）是一个跨平台的图形编程接口，用于渲染 2D 和 3D 图形。

它被广泛应用于游戏开发、计算机辅助设计、虚拟现实等领域。

OpenGL 提供了丰富的函数库，可以实现各种复杂的图形效果。

二、OpenGL 函数库OpenGL 的函数库主要可以分为核心函数库和扩展库。

核心函数库包含了基本的绘图功能，如绘制几何图元、矩阵操作、几何变换和投影变换等。

扩展库 GLEW（GLEW Extension Wrangler Library）则提供了更多的高级功能，如阴影、纹理贴图等。

1.核心函数库核心函数库包含了许多常用的绘图函数，如：- glBegin()：开始绘制- glEnd()：结束绘制- glVertex()：绘制一个顶点- glColor()：设置颜色2.矩阵操作、几何变换和投影变换函数OpenGL 提供了丰富的矩阵操作、几何变换和投影变换函数，如：- glPushMatrix()：矩阵入栈- glPopMatrix()：矩阵出栈- glTranslate()：几何变换（平移）- glRotate()：几何变换（旋转）- glScale()：几何变换（缩放）- gluPerspective()：投影变换3.扩展库 GLEWGLEW 是一个方便的扩展库，可以方便地管理 OpenGL 扩展。

它提供了一系列的函数，如：- glewInit()：初始化 GLEW- glewGetError()：获取 GLEW 错误- glewCreateContext()：创建 OpenGL 上下文- glewMakeCurrent()：设置当前 OpenGL 上下文三、OpenGL 菜单的使用OpenGL 支持交互式输入设备，如鼠标和键盘。

opengl使用方法教程

使用辅助库glaux的方法。
使用GDI和WGL函数的方法。
使用OpenGL实用函数库glut的方法。
OpenGL 使用介绍第10页
OpenGL编程方法
OpenGL与Windows的绘图方式是不同的，其区别主要
表现在以下三个方面：
Windows用GDI绘图。
OpenGL用图形操作描述表（着色描述表、绘制描
wglDeleteContext(hglrc)；
OpenGL编程方法
管理像素格式的函数
函数功能
ChoosePixelFormat() 返回与制定像素格式最相
近的像素格式
DescribePixelFormat() 得到指定制定像素格式的
信息
GetPixelFormat() 得到指定像素格式
它。
OpenGL 使用介绍第11页
OpenGL 使用介绍第12页
OpenGL编程方法
Windows提供了5个函数管理图形操作描述
表。这5个函数都有前缀“wgl”，各函数的功能本文来GIS公园
如下所示。
wglCreateContext() 建立一个图形操作描述表
wglDeleteContext() 删除一个图形操作描述表
OpenGL 使用介绍第6页
OpenGL命令语法和规范
OpenGL包含了近200个函数，分为5类：
核心函数：115个，以gl开头。
实用函数：43个，以glu开头。
辅助函数：31个，以aux开头。
专用函数：6个，以wgl开头。
Win32API函数：5个，无特定前缀。
hglrc：指定一个图形操作描述表。

OpenGl VAO VBO使用步骤

使用VAO VBO的步骤1、产生VAOvoid glGenVertexArrays(GLsizei n,GLuint *arrays);n：要产生的VAO对象的数量。

arrays：存放产生的VAO对象的名称。

2、绑定VAOvoid glBindVertexArray(GLuint array);array：要绑定的顶点数组的名字。

3、产生VBOsvoid glGenBuffers(GLsizein,GLuint * buffers);产生缓冲区对象的名称。

参数含义和glGenVertexArrays类似。

4、绑定VBOsvoid glBindBuffer(GLenumtarget,GLuint buffer);绑定一个缓冲区对象。

target可能取值是：GL_ARRAY_BUFFER,GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, orGL_PIXEL_UNPACK_BUFFER.当进行绑定之后，以前的绑定就失效了。

5、给VBO分配数据:void glBufferData( GLenum target,GLsizeiptr size,const GLvoid * data,GLenum usage);target可能取值为：GL_ARRAY_BUFFER（表示顶点数据）,GL_ELEMENT_ARRAY_BUFFER（表示索引数据）,GL_PIXEL_PACK_BUFFER（表示从OpenGL获取的的像素数据）, or GL_PIXEL_UNPACK_BUFFER（表示传递给OpenGL的像素数据）.参数含义：size：缓冲区对象字节数data：指针：指向用于拷贝到缓冲区对象的数据。

或者是NULL，表示暂时不分配数据。

6、定义存放顶点属性数据的数组：首先需要启用VAO中对应的顶点属性数组：void glEnableVertexAttribArray( GLuint index);index：指定了需要启用的顶点属性数组的索引注意：它只在OpenGL2.0及其以上版本才有。

OpenGL支持库及向导使用教程

OpenGL支持库及向导使用教程关键词：OpenGL、支持库、向导、3D、图形、编程前言当前OpenGL的应用已经相当广泛了，在各种操作系统上都能看到它在发挥作用。

使用Basic，C，C++、Pascal，Java等语言也都能进行OpenGL编程。

为了能让更多的易语言的爱好者能熟练地使用OpenGL支持库及向导，特编写了本教程。

本教程为易语言的OpenGL支持库及向导的使用教程，是一篇面向OpenGL初学者的基础教程。

希望能为广大的初学者提供一种学习的方向和捷径。

在第二章里具体介绍了支持库中涉及到的各种命令和OpenGL的使用的经验。

教程内没有过多地涉及OpenGL内部结构和运行机制，可能不适合使用其他编程语言的用户和OpenGL的高级用户。

由于作者水平有限，教程中难免有不妥甚至错误之处，希望读者不吝指正。

编者2013年5月目录第一章、OPENGL支持库的基本介绍1第二章、OPENGL的应用2第一节、建立使用O PEN GL的组件2第二节、空间定位7第三节、基础建模9第四节、绚丽的颜色11第五节、显示列表14第六节、光照、材质16第七节、光栅位图20第八节、纹理贴图23第九节、矩阵变换27第十节、混合效果31第十一节、雾化效果35第十二节、裁剪操作36第十三节、文本操作38第十四节、缓存40第三章、使用OPENGL向导44第四章、附录47第一章、OpenGL支持库的基本介绍OPenGL是“图形硬件和软件接口”。

它并不是什么编程语言，而是一组API函数，你可以使用其中的一些函数来处理图形。

OPenGL包含了从2D到3D的各种图形、图像的功能，因此它的应用非常广泛了。

常见的就有游戏的制作、电影的特效、图像处理、医疗仪器的显示、机械的模拟等等。

可能你的电脑中就有这样的一些应用软件。

通常大家的系统已经集成了OpenGL，不再需要复杂地安装。

而且硬件厂商都会提供相应的显卡驱动。

如果出现OPenGL不能显示的状况，你应该考虑升级一下显卡的驱动程序，然后看看系统是否需要更新一下，那些API的版本是否已经过时了，当然还有可能是软件的故障。

opengl 立方体纹理顶点索引定义 -回复

opengl 立方体纹理顶点索引定义-回复OpenGL立方体纹理顶点索引定义OpenGL是一种图形编程接口，用于渲染2D和3D图形。

在OpenGL中，我们可以使用纹理贴图来给图形对象添加更多的细节和逼真感。

本文将重点讨论如何使用顶点和索引来定义一个带有纹理的立方体。

第一步：顶点定义在OpenGL中，一个3D对象的顶点通常使用(x, y, z)坐标来表示。

对于立方体而言，我们可以使用8个顶点来定义。

一个立方体的八个顶点可以如下定义：顶点1: (-1.0, 1.0, 1.0)顶点2: (1.0, 1.0, 1.0)顶点3: (-1.0, -1.0, 1.0)顶点4: (1.0, -1.0, 1.0)顶点5: (-1.0, 1.0, -1.0)顶点6: (1.0, 1.0, -1.0)顶点7: (-1.0, -1.0, -1.0)顶点8: (1.0, -1.0, -1.0)这些坐标定义了立方体的8个顶点，每个顶点都具有一个唯一的坐标。

第二步：纹理坐标定义在OpenGL中，我们可以为每个顶点定义一个纹理坐标。

纹理坐标用来确定在纹理贴图中的哪个位置采样颜色。

纹理坐标通常使用(u, v)坐标表示，并且取值范围从0到1。

对于立方体来说，我们可以为每个顶点定义一个纹理坐标。

纹理坐标可以如下定义：顶点1: (0.0, 1.0)顶点2: (1.0, 1.0)顶点3: (0.0, 0.0)顶点4: (1.0, 0.0)顶点5: (0.0, 1.0)顶点6: (1.0, 1.0)顶点7: (0.0, 0.0)顶点8: (1.0, 0.0)这些纹理坐标定义了立方体的每个顶点在纹理贴图中的采样位置。

第三步：索引定义在OpenGL中，我们通常使用索引数组来确定如何连接顶点以形成图形对象。

对于立方体而言，我们可以使用索引来确定每个顶点的连接关系。

编写一个索引数组可以减少顶点的重复定义，从而节省内存。

立方体的索引定义如下所示：索引1: 0索引2: 1索引3: 2索引4: 3索引5: 4索引6: 5索引7: 6索引8: 7索引9: 0索引10: 4索引11: 1索引12: 5索引13: 2索引14: 6索引15: 3索引16: 7索引17: 0索引18: 2索引19: 1索引20: 3索引21: 4索引22: 6索引23: 5索引24: 7这些索引定义了顶点之间的连接关系，从而构建了立方体的形状。

OpenGL4.0及其以上版本中VAO顶点数组对象使用介绍

IntroductionWith the removal of OpenGL states and the fixed function mode, we no longer have any glEnableglVertex or glColor. What this means is we need a new way of transferring data to the graphics card to render our geometry. We could use VBO’s which I introduced in one of the terrain tutorials, or we could use a new feature in OpenGL 3+, known as VAO’s. VAO’s are Vertex Array Objects and allow you to store m ultiple VBO’s in one VAO. With this ability, we can now store vertex data and colour data in separate VBO’s, but in the same VAO. The same goes for all types of data you usually send through as a VBO, including data for normals or anything that you need on a per-vertex rate.What a VAO is, is a way to store object information straight on the graphics card, instead of sending vertices through to the graphics card as we need them. This is how Direct3D works as it doesn't have the immediate mode which OpenGL had up until OpenGL 3.x. This then means our application doesn't have to transfer data to and from the graphics card and we get extreme increases in performance.The best part, is that this isn't too difficult to set up. It just means that instead of a bunch of glVertex calls, we store all our vertices in an array and then place that into a VBO and then into a VAO. OpenGL takes care of everything behind the scenes, and we get all the advantages that come with VBO's and VAO's.CodingWhile I understand you may not have done the terrain tutorial which introduces VBO's, I'm going to be starting from the basics and I will still be explaining everything as I go. The best part is we don't have to do too much to get the output for this tutorial, which is a square on the screen.Open up opengl_3.h and inside of it we are going to create two variables and one method. The method will be take no parameters and will return nothing, but inside of it we will be creating our VAO and VBO to draw a square. In that mindset, I am going to call the method createSquare.void createSquare(void); // Method for creating our squares Vertex Array ObjectOur two variables are going to both be arrays of unsigned int's and they are both going to be of length 1, so we have one VAO and one VBO. I am calling these vaoID and vboID and am using these as private variables in our class.unsigned int vaoID[1]; // Our Vertex Array Objectunsigned int vboID[1]; // Our Vertex Buffer ObjectNow that's not so scary, let's go and jump into opengl_3.cpp and start making use of this. Inside of the setupScene method I am adding the call to createSquare and next we will start creating this method. Keep in mind that I am creating the square and the VAO and VBO before I actually use them, otherwise we might run into issues with empty memory.void OpenGLContext::setupScene(void) {...createSquare(); // Create our square}And now to create our createSquare method. I have jumped down to the bottom of theopengl_3.cpp file, however you can place this anywhere in the file if you prefer to order your methods by name or something of the like. Here is what the empty method will initially look like:/**createSquare is used to create the Vertex Array Object which will hold our square. We willbe hard coding in the vertices for the square, which will be done in this method.*/void OpenGLContext::createSquare(void) {}Before we create our VAO and VBO, we need some data which describes the vertices for our shape. I am drawing a square made up of two triangles, so we need 6 vertices, 3 for each triangle. Then, because we have 6 vertices, each vertex is made up of 3 values, the x, y and z coordinates, giving us a total of 18 values we need to describe our square. These are going to be float values and stored in an array called vertices. As I am using a dynamic array, don't forget to call the delete method afterwards to make sure we free up our memory again./**createSquare is used to create the Vertex Array Object which will hold our square. We willbe hard coding in the vertices for the square, which will be done in this method.*/void OpenGLContext::createSquare(void) {float* vertices = new float[18]; // Vertices for our squaredelete [] vertices; // Delete our vertices from memory}Now it's time to fill in some values for the vertices. I am going to place all the vertices at 0 on the z axis and I am going to give the square a size of 1 unit. That means I need to go up and to the left half a unit, and down and to the right half a unit as 0.5 + 0.5 = 1, giving us a length of 1 for the sides of the square. So the top left vertex is (-0.5, 0.5, 0.0) and the bottom right vertex is (0.5, -0.5, 0.0). Filling in all 18 values based on this, we get:/**createSquare is used to create the Vertex Array Object which will hold our square. We willbe hard coding in the vertices for the square, which will be done in this method.*/void OpenGLContext::createSquare(void) {float* vertices = new float[18]; // Vertices for our squarevertices[0] = -0.5; vertices[1] = -0.5; vertices[2] = 0.0; // Bottom left corner vertices[3] = -0.5; vertices[4] = 0.5; vertices[5] = 0.0; // Top left cornervertices[6] = 0.5; vertices[7] = 0.5; vertices[8] = 0.0; // Top Right cornervertices[9] = 0.5; vertices[10] = -0.5; vertices[11] = 0.0; // Bottom right corner vertices[12] = -0.5; vertices[13] = -0.5; vertices[14] = 0.0; // Bottom left corner vertices[15] = 0.5; vertices[16] = 0.5; vertices[17] = 0.0; // Top Right cornerdelete [] vertices; // Delete our vertices from memory}So we've now filled in our vertices coordinates, we need to go and create a Vertex Array Object which is done with a call to glGenVertexArrays. We then need a call to glBindVertexArray to make the VAO active. Once the VAO is active, we need to call glGenBuffers to create our Vertex Buffer Object, and then we also need to bind it with glBindBuffer.So it goes in this order:1. Generate Vertex Array Object2. Bind Vertex Array Object3. Generate Vertex Buffer Object4. Bind Vertex Buffer ObjectOnce we have done step 4, we need to fill our VBO with the vertex data. When creating VBO's, you can set why type of VBO it is, and in this case we are going for GL_STATIC_DRAW, this tells OpenGL that we do not intend on changing the data in any way, and we just want to be able to render it. There are types for data which changes as well, for all types, I suggest checking out the OpenGL API or the OpenGL wiki: /wiki/Vertex_Buffer_ObjectNow, we need to call glBufferData to set the data for our VBO to the float array we created above, before telling OpenGL that this VBO is for storing vertex data. Finally we clean up by disabling our Vertex Attribute Array and also disabling our Vertex Array Object./**createSquare is used to create the Vertex Array Object which will hold our square. We willbe hard coding in the vertices for the square, which will be done in this method.*/void OpenGLContext::createSquare(void) {...vertices[15] = 0.5; vertices[16] = 0.5; vertices[17] = 0.0; // Top Right corner glGenVertexArrays(1, &vaoID[0]); // Create our Vertex Array ObjectglBindVertexArray(vaoID[0]); // Bind our Vertex Array Object so we can use itglGenBuffers(1, vboID); // Generate our Vertex Buffer ObjectglBindBuffer(GL_ARRAY_BUFFER, vboID[0]); // Bind our Vertex Buffer ObjectglBufferData(GL_ARRAY_BUFFER, 18 * sizeof(GLfloat), vertices, GL_STATIC_DRAW); // Set the size and data of our VBO and set it to STATIC_DRAWglVertexAttribPointer((GLuint)0, 3, GL_FLOAT, GL_FALSE, 0, 0); // Set up our vertex attributes pointerglEnableVertexAttribArray(0); // Disable our Vertex Array ObjectglBindVertexArray(0); // Disable our Vertex Buffer Objectdelete [] vertices; // Delete our vertices from memory}What we have now, is a VAO with a VBO storing vertex data for a square. So far it's been straight forward, so now we need to render this data to the screen. Go ahead and jump to our renderScene method and after we set our glUniformMatrix4vf variables for our shader from the previous tutorial, we need to add three lines of code to render. First off we need to enable our Vertex Array Object, then we need to draw the VAO and finally disable the VAO. Like so:glBindVertexArray(vaoID[0]); // Bind our Vertex Array ObjectglDrawArrays(GL_TRIANGLES, 0, 6); // Draw our squareglBindVertexArray(0); // Unbind our Vertex Array ObjectAnd well done, you can now create a square using no immediate mode and storing everything on the graphics card, which will run at maximum framerates. One more optimization to this, would be to use a GL_TRIANGLE_STRIP instead of GL_TRIANGLES and you could get away with 4 vertices. In the next tutorial we will look at adding colour to our square.If you have any questions you can comment below or email me at swiftless@。

OpenGL使用

OpenGL使⽤第⼀讲：基本概念前⾔随着计算机多媒体技术、可视化技术及图形学技术的发展，我们可以使⽤计算机来精确地再现现实世界中的绚丽多彩的三维物体，并充分发挥⾃⾝的创造性思维，通过⼈机交互来模拟、改造现实世界，这就是⽬前最为时髦的虚拟现实技术。

通过这种技术，建筑⼯程师可以直接设计出美观的楼房模型；军事指挥员可以模拟战场进⾏军事推演，⽹民可以⾜不出户游览故宫博物馆等名胜古迹等。

⽽虚拟现实技术最重要的⼀部分内容就是三维图形编程。

当前，三维图形编程⼯具中最为突出的是SGI公司的OpenGL（Open Graphics Language，开放式的图形语⾔）,它已经成为⼀个⼯业标准的计算机三维图形软件开发接⼝，并⼴泛应⽤于游戏开发、建筑、产品设计、医学、地球科学、流体⼒学等领域。

值得⼀提的是，虽然微软有⾃⼰的三维编程开发⼯具DirectX，但它也提供OpenGL图形标准，因此，OpenGL 可以在微机中⼴泛应⽤。

⽬前，OpenGL在国内外都掀起了热潮，但国内对这⼀领域介绍的资料并不是很多，特别是有志于在图形图像⽅⾯进⾏深⼊研究的读者朋友，常常苦于不掌握OpenGL编程接⼝技术，⽆法向纵深领域扩展。

为了开启三维图形编程这扇神秘⼤门，本讲座在结合OpenGL 有关理论知识的基础上，着重介绍Visual C++6.0开发环境中的编程实现，由于⽔平有限，本讲座可能⽆法⾯⾯俱到，存在⼀些疏漏，但相信它可以将开启"神秘⼤门"的钥匙交给读者朋友们。

⼀、OpenGL的特点及功能OpenGL是⽤于开发简捷的交互式⼆维和三维图形应⽤程序的最佳环境，任何⾼性能的图形应⽤程序，从3D动画、CAD辅助设计到可视化访真，都可以利⽤OpenGL⾼质量、⾼性能的特点。

OpenGL⾃1992年出现以来，逐渐发展完善，已成为⼀个唯⼀开放的，独⽴于应⽤平台的图形标准，⼀个典型的OpenGL应⽤程序可以在任何平台上运⾏--只需要使⽤⽬标系统的OpenGL库重新编译⼀下。

OpenGL顶点缓冲区对象（VBO）

OpenGL顶点缓冲区对象（VBO）转载创建VBOGL_ARB_vertex_buffer_object 扩展可以提升OpenGL的性能。

它提供了顶点数组和显⽰列表，这避免了低效实现这些功能。

Vertex buffer object (VBO) 允许顶点数据储存在⾼性能显卡上，即服务端的内存中，改善数据传输效率。

如果缓冲区对象保存了像素数据，它就被称做Pixel Buffer Object (PBO)。

使⽤顶点数据可以减少函数调⽤次数及复⽤共享顶点，然⽽，顶点数组的缺点是顶点函数及顶点数据在客户端(me:对于OpenGL来说，显卡为服务端，其它为客户端),每次引⽤顶点数组时，都必须将顶点数据从客户端(me:内存)发送到服务端(显卡)。

另⼀⽅⾯，显⽰列表是服务端的函数，它不会再重头传送数据。

但是，⼀旦显⽰列表被编译了，显⽰列表中的数据就不能修改了。

Vertex buffer object (VBO) 为顶点创建创建了⼀个缓冲区对象。

缓冲区对象在服务端的⾼性能内存中，并提供了相同的函数，引⽤这些数组，如glVertexPointer(), glNormalPointer(), glTexCoordPointer(), 等等.顶点缓冲区内存管理器将缓冲区对象放在储存器中最佳的位置。

这依赖了⽤户输⼊的模式:"target"模式和"usage"模式。

因此，储存管理器可以优化缓冲区，平衡三种内存：system ,AGP, video memory。

与显⽰列表不同的是，在顶点缓冲区对象中的数据可以读也可以将它映射到服务端的内存空间中，然后更新它的数据。

VBO另⼀个重要的优点是，可以在许多客户端中共享缓冲区对象，就像显⽰列表和纹理那样。

由于VBO在服务端，多个客户端可以通过对应的标识符访问同⼀个缓冲区。

创建VBO创建VBO的三个步骤：1.使⽤glGenBuffersARB()得到⼀个新的缓冲区对象。

opengl教程（2）在窗口画点

opengl教程（2）在窗⼝画点原⽂地址：通常在写OpenGL程序时候，我们都需要glew库，该库包装了OpenGL的各种扩展，便于我们使⽤。

我们可以在main函数中调⽤glew初始化函数，之后就可以查询OpenGL各种扩展能否使⽤了，对于能够使⽤的函数，可以动态的加载。

在这篇教程中，我们⾸先了解⼀下顶点缓冲对象(VBO,vertex buffer object)的⽤法。

在计算机图形学的3D世界中，三维物体对象都是由⼀系列顶点组成的，⽐如武⼠模型、城堡模型等等(注意下⾯两副图），这些顶点相连接，组成mesh(三⾓形)。

顾名思义，顶点缓冲就是保存顶点的内存对象，通常VBO是GPU显存中的⼀块区域，使⽤VBO可以加速顶点的读取速度。

在本篇教程和下⼀篇教程中，我们仅使⽤OpenGL中固定管线（相对固定管线的是可编程管线)的编程⽅法分别来画⼀个点和⼀个三⾓形。

我们并没有对所渲染的物体(就是⼀个点或⼀个三⾓形)进⾏平移、缩放、旋转等操作，实际上我们只是在归⼀化的裁剪空间中来安排我们的物体，可以把归⼀化的裁剪空间看成⼀个正⽅体，坐标原点在正⽅形的中⼼，x, y,z坐标的范围都是[-1.0,1.0]，我们把物体映射到屏幕空间(可以看作⽴⽅体中的物体先投影到z=-1的⾯上，然后该⾯的四边形映射到屏幕空间)，⽐如屏幕空间是1024*768，则x坐标-1，映射到0，+1映射到1023，x和y等于0的点，则被映射到屏幕中⼼，最终根据draw函数中指定的体元语义，通过光栅化操作，把物体在屏幕空间画出来。

下⾯我们看下程序的部分源代码实现：#include <GL/glew.h>⾸先我们要包含glew头⽂件，注意我们要把这个头⽂件放在freee_glut.h的前⾯，否则的话，程序编译有可能出错。

#include "math_3d.h"在这篇教程中，我们画⼀个顶点，顶点结构在math_3d.h中定义。

OPENGL VAO VBO使用步骤

opengl入门教程

opengl使用手册 简书

OPENGL怎么用

vbo协议的介绍

使用OpenGL VBO扩展

android OpenGL ES 笔记 3-VBO的使用步骤

OpenGL渲染流程

现代 OpenGL 教程 01 - 入门指南说明书

OpenGL中VA,VAO,VBO和EBO的区别

VBO软件操作手册

CSharpGL创建和使用VBO的最佳方式

opengl使用手册 简书

opengl使用方法教程

OpenGl VAO VBO使用步骤

OpenGL支持库及向导使用教程

opengl 立方体 纹理 顶点 索引 定义 -回复

OpenGL4.0及其以上版本中VAO顶点数组对象使用介绍

OpenGL使用

OpenGL顶点缓冲区对象（VBO）

opengl教程（2）在窗口画点

opengl使用手册简书

opengl使用手册简书

opengl 立方体纹理顶点索引定义 -回复