精华内容
下载资源
问答
  • opengles之IBO

    2017-05-16 15:13:18
    opengles ibo
  • IBO博客系统源代码

    2021-03-18 11:57:20
    IBO博客系统是一个基于 SpringBoot/MongoDB 的博客系统。IBO形容的是印记:印记博客。想必大家都希望自己的博客记录自己所想,留有所念,留下胜过的印记。 IBO博客系统特性: 支持Markdown等软文发布 设计简洁,界面...
  • IBO博客系统 v2.0.2

    2020-12-28 21:13:48
    为您提供IBO博客系统下载,IBO博客系统是一个基于 SpringBoot/MongoDB 的博客系统。IBO形容的是印记:印记博客。想必大家都希望自己的博客记录自己所想,留有所念,留下胜过的印记。IBO博客系统特性:支持Markdown等...
  • IBO5.0.2 for XE2

    2014-02-27 02:17:20
    componente IBO5.0.2 for xe2.
  • ibo5.11.1_2861_Source.zip

    2019-08-29 16:49:20
    ibo5.11.1_2861_Source.zip`
  • ibo5.5.3_2067_Source.rar

    2019-06-17 12:56:05
    ibo5.5.3_2067_Source.rar
  • ibo5.9.1_2522_Source

    2017-06-12 09:56:46
    ibo5_9_1_b2522_Source
  • 身临其境的票房(IBO)是一种创新的售票系统,可将购票转变为互动式的身临其境的体验。 通过最新的3D网络技术,IBO通过全新的导航和虚拟现实范式将买家带入一个吸引人的,身临其境的3D环境,从而简化了购票过程。 ...
  • IBO D24III处理器调试软件(英文版)
  • ibo5.2.0_b01_RawSource.7z

    2019-06-17 12:50:04
    ibo5.2.0_b01_RawSource.7z
  • IBO 5.5.3 Build 2067

    2014-05-13 07:50:04
    IBO 5.5.3 Build 2067 Change Log: 5/8/2014 Version 5.5.3 [Build 2067] I fixed a bug having to do with TIBOBCDField. It was getting a BCD Overflow error when the column value was NULL. I fixed a...
  • ibo5.2.0_b01_RawSource

    2013-07-17 21:02:22
    ibo5.2.0_b01_RawSource
  • OpenGL 理解VAO VBO 和 IBO

    2020-02-20 11:18:42
    VAO VBO 和 IBO 曾经有一个老师在教我们的时候,给我们说了一句很实在的话,当你接触一个新的领域的时候,什么最压人?名词最压人,随便一个专有名词都够你吃一壶的。事实上确实如此。 学习OpenGL首先,先要弄...

    VAO VBO 和 IBO

     

    曾经有一个老师在教我们的时候,给我们说了一句很实在的话,当你接触一个新的领域的时候,什么最压人?名词最压人,随便一个专有名词都够你吃一壶的。事实上确实如此。

     

    学习OpenGL首先,先要弄明白的三个名词就是VAO,VBO和IBO。我们学习一个东西的时候,往往被过多,过详细的数据,淹没真正核心的那几句话,这可能也是不同人学习能力不一样的原因把,我应该属于学习能力比较弱的那种,总是要一边叮嘱自己,关键那几句话在哪?一边看东西,才能勉强找到关键那几句话。

     

    本篇不是教程,不会说明这三个玩意的来龙去脉以及用法,只是在你已具备相应基础的前提下,加深一下认知。

     

    VAO:顶点数组对象,Vertex Array Object

    VBO:顶点缓存对象,Vertex Buffer Object,VBO

    IBO:顶点索引对象,Element Buffer Object,EBO或Index Buffer Object,IBO

     

    借用一下LearnOpenGL网站上的图。

     

    最让我迷惑的不是IBO,而是VAO的作用,其实这VAO和IBO一样,都是为了“复用”。而VBO关键作用在于“打包”上传。

     

    从上图看来,VAO,其实是VBO的约束器,解读器。它管理一类VBO的配置。VAO1,只用到一个属性,VAO2则有两个属性,位置和颜色。同时还要用AttributePointer去描述VBO。

     

    1、VAO

    顶点数组对象:

    使用VAO的好处——复用属性设置。

    1、VAO是可复用的

    2、VAO可以绑定一系列顶点属性

    3、VAO只能和匹配的VBO绑定,比如你VAO只描述了位置,而VBO包含了顶点和颜色信息,他们不能绑定,否则数据就错乱了

    4、VAO解绑后可以绑定给其他匹配的VBO,这就是“复用”。

    2、VBO

    顶点缓存对象:

    使用VBO的好处——批量数据传输。

    具体来讲:使用VBO好处是可以一次发送大量顶点到显卡,而不是每次只发送一个顶点。

     

    这里额外思考一下,既然IO是相当费时的,那么如果内存和显卡可以异步传输数据是不是能节省掉一部分时间?比如先传A数据,然后渲染A的同时传B的树呢?这应该就是多线程渲染做的事情,并不是真的多线程渲染,而是把渲染和IO交错以节省时间。当然如果瓶颈不是IO,而是渲染本事,那多线程渲染也无力回天了。

    3、IBO

    先对来讲IBO是最好理解的,假定一个四边形由两个三角形组成,共六个顶点,实际上有两对顶点共享,所以只有四个顶点,IBO用来告诉你,如何复用这些顶点。

    比如0,1,3是一个三角形,1,2,3是另一个三角形。

     

    这就是IBO的复用。

     

    依据以上总结,在回头来看这段源代码,就思路就相对清晰了。

     

    //声明顶点数据,实际应用的时候,应该是从FBX等文件里面读取的。
    //很少自己生成
    float vertices[] = {
        -0.5f, -0.5f, 0.0f, // left  
        0.5f, -0.5f, 0.0f, // right 
        0.0f,  0.5f, 0.0f  // top   
    };
    
    //创建顶点数组对象和顶点缓存对象
    unsigned int VBO, VAO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    
    //绑定,或者说“选用”这个顶点缓存对象。
    glBindVertexArray(VAO);	
    
    //绑定VBO对象,并拷贝数据到VBO
    //注意数据不是拷贝给VAO的,VAO里面不存顶点数据
    //GL_STATIC_DRAW,这是不是Unity区分Static和non-static物件的原因?
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), 
                 vertices, GL_STATIC_DRAW);
    
    //描述顶点,并把它在0号位置激活,一个VAO可以有多个描述对象。
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    
    //相当于解除绑定。注意是解绑,不是删除。
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    //简单来讲,按照绑定的反顺序进行解绑就对了。先解绑VBO,再解绑VAO
    glBindVertexArray(0);
    //到此位置,该送入GPU的数据以及都“送”进去了
    
    //开始进入渲染主循环
    while (!glfwWindowShouldClose(window))
    {
        //处理输入
        processInput(window);
        //清屏
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        //选择shader,这里不是本篇要讲的内容,略过
        glUseProgram(shaderProgram);
        //因为没有其他数据,所以不用绑定解绑也没事,这么做是为了规范。
        //思考:当VBO有多个的时候,这里要怎么做?
        glBindVertexArray(VAO); 
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glBindVertexArray(0);
        
        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    
    //这里才是删除缓存
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);    
    

     

    展开全文
  • 索引缓冲对象(IBO)(1) 创建IBO(2)设置IBO的数据(3)绘制2. 线框模式 1. 索引缓冲对象(IBO) 索引缓冲对象(Element Buffer Object, EBO,也叫Index Buffer Object, IBO)。假设我们要绘制得不是三角形,...


    1. 索引缓冲对象(IBO)

    索引缓冲对象(Element Buffer Object, EBO,也叫Index Buffer Object, IBO)。假设我们要绘制得不是三角形,而是四边形,那么我们要写生成得节点组合可能是这样的:

    GLfloat vertices[] = {
        // 第一个三角形
        0.5f, 0.5f, 0.0f,   // 右上角
        0.5f, -0.5f, 0.0f,  // 右下角
        -0.5f, 0.5f, 0.0f,  // 左上角
        // 第二个三角形
        0.5f, -0.5f, 0.0f,  // 右下角
        -0.5f, -0.5f, 0.0f, // 左下角
        -0.5f, 0.5f, 0.0f   // 左上角
    };
    

    可以看到我们要生成得四边形只有4个顶点,而我们却生成6个顶点。如果一个模型有很对顶点,为了避免不必要得开销,索引我们引入了索引缓冲对象。IBO是一个索引顶点得缓冲对象,OpenGL调用这些顶点的索引来决定该绘制哪些顶点。我们只需要定义顶点和绘制矩形所需的索引:

    GLfloat vertices[] = {
        0.5f, 0.5f, 0.0f,   // 右上角
        0.5f, -0.5f, 0.0f,  // 右下角
        -0.5f, -0.5f, 0.0f, // 左下角
        -0.5f, 0.5f, 0.0f   // 左上角
    };
    
    GLuint indices[] = { // 注意索引从0开始! 
        0, 1, 3, // 第一个三角形
        1, 2, 3  // 第二个三角形
    };
    

    (1) 创建IBO

    同VBO使用函数 glGenBuffers 创建一个IBO对象

    // 创建IBO
    GLuint m_nIBOId;
    glGenBuffers(1, &m_nIBOId);
    

    (2)设置IBO的数据

    使用函数 glBindBuffer 绑定IBO, 函数 glBufferData 设置IBO的数据

    // 初始化IBO
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_nIBOId);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    

    (3)绘制

    使用函数 glDrawElements 绘制

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_nIBOId);
    // 绘制
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    

    函数 glDrawElements 的原型如下:
    glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)

    • 参数 mode : 绘制模式, GL_TRIANGLES 为三角形。
    • 参数 count : 绘制的顶点数目。
    • 参数 type : 数据的类型,这里索引数据存储的为 GL_UNSIGNED_INT
    • 参数 indices : 表示偏移。

    下图为绘制的四变型效果:
    Qt与OpenGL编程 - IBO与线框模式

    2. 线框模式

    函数 glPolygonMode 表示OpenGL使用何种方式绘制图元。

    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    

    表示使用线框模式,效果如下图说是
    Qt与OpenGL编程 - IBO与线框模式
    如果要恢复成填充模式,可以使用如下代码:

    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    

    完整代码如下:
    头文件:

    #ifndef OPENGLRENDERWIDGET_H
    #define OPENGLRENDERWIDGET_H
    
    #include <QOpenGLWidget>
    #include <QOpenGLShader>
    #include <QOpenGLShaderProgram>
    #include <QOpenGLFunctions_2_0>
    #include <QOpenGLFunctions_3_3_Core>
    
    class OpenglRenderWidget : public QOpenGLWidget, public QOpenGLFunctions_2_0
    {
        Q_OBJECT
    public:
        struct VertexAttributeData
        {
            // Postion
            float pos[3];
            float color[3];
        };
    
    public:
        OpenglRenderWidget(QWidget* parent = nullptr);
        ~OpenglRenderWidget();
    
    protected:
        void initializeGL() override;
        void resizeGL(int w, int h) override;
        void paintGL() override;
    
    private:
        bool initShaderProgram(void);
        void createVertexAttributeData(VertexAttributeData* pVetAttr);
    
        GLuint m_shaderProgramId;
        QOpenGLShaderProgram* m_pShaderProgram = nullptr;
        QOpenGLShader* m_pVertexShader = nullptr;
        QOpenGLShader* m_pFragmentShader = nullptr;
    
        GLuint m_nVBOId;
        GLuint m_nIBOId;
    
        // Attribute Location
        GLint m_nPosAttrLocationId;
        GLint m_nColorAttrLocationId;
    };
    
    #endif
    
    

    cpp文件

    #include "OpenglRenderWidget.h"
    #include <QDebug>
    
    OpenglRenderWidget::OpenglRenderWidget(QWidget* parent)
        :QOpenGLWidget(parent)
    {
    
    }
    
    OpenglRenderWidget::~OpenglRenderWidget()
    {
    
    }
    
    void OpenglRenderWidget::initializeGL()
    {
        this->initializeOpenGLFunctions();
    
        // 初始化GPU程序
        bool result = initShaderProgram();
        if (!result)
            return;
    
        m_shaderProgramId = m_pShaderProgram->programId();
        // 获取位置和颜色的locationID
        m_nPosAttrLocationId = glGetAttribLocation(m_shaderProgramId, "pos");
        m_nColorAttrLocationId = glGetAttribLocation(m_shaderProgramId, "color");
    
        // 创建顶点属性数据
        VertexAttributeData vAttrData[4];
        createVertexAttributeData(vAttrData);
        // 创建IBO数据
        GLuint indices[] = {0, 1, 3, 1, 2, 3};
    
        // 创建VBO
        glGenBuffers(1, &m_nVBOId);
        // 创建IBO
        glGenBuffers(1, &m_nIBOId);
    
        // 初始化VBO
        glBindBuffer(GL_ARRAY_BUFFER, m_nVBOId);
        glBufferData(GL_ARRAY_BUFFER, sizeof(vAttrData), vAttrData, GL_STATIC_DRAW);
    
        // 初始化IBO
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_nIBOId);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    
        // 设置顶点信息属性指针
        glVertexAttribPointer(m_nPosAttrLocationId, 4, GL_FLOAT, GL_FALSE, sizeof(VertexAttributeData), (void*)0);
        glEnableVertexAttribArray(m_nPosAttrLocationId);
        // 设置原色信息属性指针
        glVertexAttribPointer(m_nColorAttrLocationId, 4, GL_FLOAT, GL_FALSE, sizeof(VertexAttributeData), (void*)(sizeof (float) * 3));
        glEnableVertexAttribArray(m_nColorAttrLocationId);
    
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
    }
    
    void OpenglRenderWidget::resizeGL(int w, int h)
    {
        this->glViewport(0, 0, w, h);
    
        return QOpenGLWidget::resizeGL(w, h);
    }
    
    void OpenglRenderWidget::paintGL()
    {
        glClearColor(51.0f / 255.0f, 76.0f / 255.0f, 76.0f / 255.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    
        // 使用shader
        m_pShaderProgram->bind();
    
        //glBindBuffer(GL_ARRAY_BUFFER, m_nVBOId);
    //    // 绘制
    //    glDrawArrays(GL_POLYGON, 0, 4);
        //glBindBuffer(GL_ARRAY_BUFFER, 0);
    
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_nIBOId);
        // 绘制
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    
    
        m_pShaderProgram->release();
    }
    
    bool OpenglRenderWidget::initShaderProgram(void)
    {
        m_pShaderProgram = new QOpenGLShaderProgram(this);
    
        // 加载顶点着色器
        QString vertexShaderStr(":/vertexshader.vsh");
        m_pVertexShader = new QOpenGLShader(QOpenGLShader::Vertex, this);
        bool result = m_pVertexShader->compileSourceFile(vertexShaderStr);
        if (!result)
        {
            qDebug() << m_pVertexShader->log();
            return false;
        }
    
        // 加载片段着色器
        QString fragmentShaderStr(":/fragmentshader.fsh");
        m_pFragmentShader = new QOpenGLShader(QOpenGLShader::Fragment, this);
        result = m_pFragmentShader->compileSourceFile(fragmentShaderStr);
        if (!result)
        {
            qDebug() << m_pFragmentShader->log();
            return false;
        }
    
        // 创建ShaderProgram
        m_pShaderProgram = new QOpenGLShaderProgram(this);
        m_pShaderProgram->addShader(m_pVertexShader);
        m_pShaderProgram->addShader(m_pFragmentShader);
        return m_pShaderProgram->link();
    }
    
    void OpenglRenderWidget::createVertexAttributeData(VertexAttributeData* pVetAttr)
    {
        // 第一个点位置信息
        pVetAttr[0].pos[0] = -0.5f;
        pVetAttr[0].pos[1] = 0.5f;
        pVetAttr[0].pos[2] = 0.0f;
        // 第一个点颜色信息
        pVetAttr[0].color[0] = 1.0f;
        pVetAttr[0].color[1] = 0.0f;
        pVetAttr[0].color[2] = 0.0f;
    
        // 第二个点位置信息
        pVetAttr[1].pos[0] = -0.5f;
        pVetAttr[1].pos[1] = -0.5f;
        pVetAttr[1].pos[2] = 0.0f;
        // 第二个点颜色信息
        pVetAttr[1].color[0] = 0.0f;
        pVetAttr[1].color[1] = 1.0f;
        pVetAttr[1].color[2] = 0.0f;
    
        // 第三个点位置信息
        pVetAttr[2].pos[0] = 0.5f;
        pVetAttr[2].pos[1] = -0.5f;
        pVetAttr[2].pos[2] = 0.0f;
        // 第三个点颜色信息
        pVetAttr[2].color[0] = 0.0f;
        pVetAttr[2].color[1] = 0.0f;
        pVetAttr[2].color[2] = 1.0f;
    
        // 第四个点位置信息
        pVetAttr[3].pos[0] = 0.5f;
        pVetAttr[3].pos[1] = 0.5f;
        pVetAttr[3].pos[2] = 0.0f;
        // 第四个点颜色信息
        pVetAttr[3].color[0] = 0.0f;
        pVetAttr[3].color[1] = 1.0f;
        pVetAttr[3].color[2] = 1.0f;
    }
    
    
    展开全文
  • VBO、IBO和FBO

    VBO:顶点缓冲,也就是说把顶点的存储在 显卡中开辟内存,提高传递的效率。也可以说叫顶点坐标的 缓冲区。

    //创建vbo
    glGenBuffers(1,&_vbo);
    //绑定vbo
    glBindBuffer(GL_ARRAY_BUFFER,_vbo);
    //copy数据到显存
    //
    // GL_STREAM_DRAW		不经常变化
    //GL_STATIC_DRAW		常量
    //GL_DYNAMIC_DRAW        经常变化
    
    glBufferData(GL_ARRAY_BUFFER,sizeof(vertexs),vertexs,GL_STATIC_DRAW);
    //修改部分数据
    //glBufferSubData()
     //绑定完之后 恢复状态
    glBindBuffer(GL_ARRAY_BUFFER,0);
    
    

    使用:

    //使用绑定的vbo
    glBindBuffer(GL_ARRAY_BUFFER,_vbo);
    
    //绘制过程
    
    //关闭vbo
     glBindBuffer(GL_ARRAY_BUFFER,0);
    

    IBO:索引缓冲,按照索引进行连接,提高效率。按照索引去
    画 图形。

    创建

     glGenBuffers(1,&_indexbo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,_indexbo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(indexBuf),indexBuf,GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
    
    

    使用

    //开启
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,_indexbo);
    //绘制 使用 glDrawElements进行索引绘制
    //关闭
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
    
    

    FBO:帧缓存,将我们需要绘制的物体,会知道纹理上,最后在把纹理绘制一遍。这也叫离屏渲染。

    FBO创建/开始使用/结束使用

    virtual void beginFBO(unsigned FBOID,unsigned textureId)
    {
    	glBindFramebuffer(GL_FRAMEBUFFER,FBOID);
    	//把数据渲染到纹理 的0级上
    	glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D,textureId,0);
    }
    
    
    virtual void endFBO(unsigned FBOID,unsigned textureId)
    {
    	glBindFramebuffer(GL_FRAMEBUFFER,0);
    }
    virtual std::pair(unsigned,unsigned)  createFBO(int width ,int height)
     {	
    	std::pair(unsigned,unsigned) buf;
    	//unsigned FBOID;
    	//unsigned RBOID;
    	//生产1个帧buffer
    	glGenFramebuffers(1,&buf.first);
    	//绑定framebuffer
    	glBindFramebuffer(GL_FRAMEBUFFER,buf.first);
    		
    	//产生render buffer
    	glGenRenderbuffers(1,&buf.second);
    	//绑定render buffer
    	glBindFramebuffer(GL_RENDERBUFFER,buf.second);
    
    	//指明缓冲区存储内容
    	glRenderbufferStorage(GL_RENDERBUFFER,GL_DEPTH_COMPONENT16,width,height);
    	//关闭render buffer
    	glBindFramebuffer(GL_RENDERBUFFER,0);
    	
    	//关联
    	glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_RENDERBUFFER,buf.second);
    	//关闭frame buffer
    	glBindFramebuffer(GL_FRAMEBUFFER,0);
    
    	return buf;
     }
    
    

    使用的伪代码

     createFBO();
     onrender
     {
    	 beginFBO();
    	 {
    		 //所有的绘制都 绘制到了纹理上		 
    	 }
    	 endFBO();
    
    	 shader.bgein();
    	 //画FBO纹理
    	 shader.end();
     }
    
    展开全文
  • opengl es VBO IBO VAO学习

    2017-05-11 20:46:02
    opengl es VBO IBO VAOVBO Vertex Buffer Object 其实就是显卡中的显存,可以将要绘制的顶点数据缓存在显存中,从而免去将要绘制的顶点数据重复从CPU发送到GPU, 提高渲染速度。IBO Indices Buffer Object 索引...

    opengl es VBO IBO VAO

    VBO Vertex Buffer Object
    其实就是显卡中的显存,可以将要绘制的顶点数据缓存在显存中,从而免去将要绘制的顶点数据重复从CPU发送到GPU, 提高渲染速度。

    IBO Indices Buffer Object
    索引缓冲对象,和VBO一样,只是存储的是索引数组。

    VAO Vertex Array Object
    是一个容器,可以绑定VBO和IBO的一个包装对象,把有关联的VBO和IBO一起绑定到一个VAO上,然后使用VAO就可以进行绘制了,绘制效率更高,VAO可以使开发更加灵活。

    1、

    // 0,1,2代表着色器的input的location,分别代表顶点位置,顶点颜色,顶点纹理坐标     
    glEnableVertexAttribArray(0); 
    // 固定管线使用glEnableClientState(GL_VERTEX_ARRAY)
    glEnableVertexAttribArray(1);
     // 固定管线使用glEnableClientState(GL_COLOR_ARRAY)
    glEnableVertexAttribArray(2); 
    // 固定管线使用glEnableClientState(GL_TEXTURE_COORD_ARRAY)
    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, vertexes); 
    // 固定管线使用glVertexPointer(4, GL_FLOAT, 0, vertexes);
    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, colores); 
     // 固定管线使用glColorPointer(4, GL_FLOAT, 0, colores);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, texCoordes); 
     // 固定管线使用glTexCoordPointer(2, GL_FLOAT, 0, texCoordes);

    2、
    // 绘制一个四边形

    glDrawArrays(GL_QUADS, 0, 4);

    3、
    // 指定顶点数据,注意渲染顺序的迎风面是逆时针还是顺时针,绘制4个顶点,分别对应顶点数组中的前4个顶点

    GLuint indexes = {0, 1, 2, 3};
    // 用顶点索引进行绘制的绘制调用
    glDrawElements(GL_QUADS, 4, GL_UNSIGNED_INT, indexes);

    4、// 生成VBO,并为VBO绑定顶点数据

    size_t dataSize = sizeof(GLfloat) * vertexCount * 4; // 在图像显卡中需要分配的内存大小
    GLuint vbos[1] = { 0 }; // VBO名字
    glGenBuffers(1, vbos);  // 生成一个可用的VBO名字
    GLuint vertexVBO = vbos[0];
    glBindBuffer(GL_ARRAY_BUFFER, vertexVBO); // 绑定当前的VBO,GL_ARRAY_BUFFER是VBO使用的固定参数
    glBufferData(GL_ARRAY_BUFFER, dataSize, vertexes, GL_STATIC_DRAW); 
    //将位置数据绑定到当前的VBO上,dataSize是需要的内存大小,vertexes是顶点的位置数据
    
    /*
    GL_STATIC_DRAW 是一个性能提示参数,这个参数指示了当前VBO的用途,该参数必须是GL_STREAM_DRAW, GL_STATIC_DRAW, or GL_DYNAMIC_DRAW之一。openGL会根据该指示,尽可能将数据放置在性能最优的内存中,可能是显存,AGP内存,或者cpu内存中.
    GL_STATIC_DRAW:数据指定一次,并多次被用于绘制。
    GL_STREAM_DRAW:数据指定一次,最多几次用于绘制。
    GL_DYNAMIC_DRAW:数组多次指定,多次用于绘制。
    */
    
    //使用VBO进行绘制,和使用顶点数组类似
    //数据在缓冲区中的偏移位置,和顶点数组指针位置效果类似
    #define BUFFER_OFFSET(offset) ((GLvoid*)(NULL + offset)) 
    
    glBindBuffer(GL_ARRAY_BUFFER, vertexVBO); // 绑定位置VBO
    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); // 指定位置数据
    glBindBuffer(GL_ARRAY_BUFFER, colorVBO); // 绑定颜色VBO
    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); // 指定颜色数据
    glBindBuffer(GL_ARRAY_BUFFER, textureVBO); // 绑定纹理VBO
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); // 指定纹理数据
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glDrawArrays(GL_QUADS, 0, m_vertexCount); // 绘制

    5、IBO: 索引缓冲对象,和VBO一样,只是存储的是索引数组。

    GLuint ibos[1] = { 0 }; // IBO名字
    GLuint IBO;
    glGenBuffers(1, &IBO);  // 生成可用的IBO名字  
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO); 
    //参数必须使用GL_ELEMENT_ARRAY_BUFFER
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * indexCount, indexes, GL_STATIC_DRAW);
    //将索引数据绑定到当前的IBO上,GL_STATIC_DRAW同上面的VBO中第使用
    //绘制
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
    glDrawElements(GL_QUADS, indexCount, GL_UNSIGNED_INT, BUFFER_OFFSET(0));
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    6、生成VAO

    GLuint VAO;; // VAO名字
    glGenVertexArrays(1, &VAO); // 生成一个VAO
    glBindVertexArray(VAO); // 绑定到当前的VAO
    
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO); // 绑定一个IBO到当前的VAO上
    
    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);
    glEnableVertexAttribArray(2);
    
    glBindBuffer(GL_ARRAY_BUFFER, vertexVBO); // 绑定位置VBO到当前的VAO上
    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); // 指定位置数据
    glBindBuffer(GL_ARRAY_BUFFER, colorVBO); // 绑定颜色VBO到当前的VAO上
    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); // 指定颜色数据
    glBindBuffer(GL_ARRAY_BUFFER, textureVBO); // 绑定纹理VBO到当前的VAO上
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); // 指定纹理数据
    
    // 绘制
    
    glBindVertexArray(VAO);
    glDrawElements(GL_QUADS, indexCount, GL_UNSIGNED_INT, BUFFER_OFFSET(0));
    glBindVertexArray(0);
    展开全文
  • IBO:   索引缓冲对象,一个立方体就8个顶点,但我们之前绘制时传输6个面,24个顶点,这些顶点很多是重复的,影响传输效率,而且占用内存也较高。   所以引入IBO机制。IBO存储顶点索引,绘制三角形时根据IBO索引...
  • 大家好,这是我的OpenGL ES 高级进阶系列...今天给大家介绍VBO(Vertex Buffer Object)和IBO(Index Buffer Object),让我们先从一段代码开始,逐步介绍它们: // 将三角形顶点数据放入buffer中 // Put the triang...
  • 初学OpenGL之VBO、VAO、EBO\IBO

    千次阅读 2017-12-25 13:19:32
    初学OpenGL之VBO、VAO、EBO\IBO
  • VBO:顶点缓冲区 IBO:索引缓冲区 VBO的作用:在不使用VBO的情况下,每次调用glDrawArrays或glDrawElements的时候,都要把数据从内存拷贝到显卡,频繁的绘制内存和显卡之间就要频繁的拷贝数据这会增加很多开销,而VBO就是...
  • 导读:关于IBO市场的各种分析如天花烂坠,但大都如耍流氓般只给结论,让阅读者怀疑人生,信也不是不信也不是。而本文作者从经济学、金融学基础原理出发,将IBO市场的金融特性、...
  • [Modern OpenGL]谈谈VAO、VBO、IBO

    千次阅读 2018-01-02 15:11:17
    OpenGL中的VAO、VBO、IBO刚开始学习OpenGL的时候可能会对VAO、VBO、IBO的概念有些模糊,只是记得这些术语和API。 理清概念才能更好的使用这些API,下面我们花20分钟的时间谈谈这些术语。 VBO : Vertex Buffer ...
  • 文章目录前言VBO链接顶点属性EBO(IBO)VAO绑定顺序解绑顺序 前言 首先感谢知乎的一篇文章,解答了我的疑惑,在此记录一下心得。 那么我们先简单介绍一下这三个对象,以及一些必要操作。 VBO VBO,全称Vertex Buffer ...
  • 近日,我们的运营经理在浏览国外区块链新闻时,竟然发现“IBO”的版本不止一个。很多项目都打着“IBO”的旗号,堂而皇之地招摇过市。那么,这些都称为“IBO”的项目,各自有哪些区别呢? 我们都知道,“IBO”的提法...
  • 在计算机中,所有的图像都是有三角形组成,绘制立方也是通过绘制...答案就是IBO(index buffer object),在一个vbo中,保存这6个定点,指定36个定点时,通过索引从这6个定点中取值。另外,为了是代码更加简洁,将一些向
  • opengl中VAO,VBO,IBO用法小结 这三个玩意全面取代旧社会的glBegin/glEnd,显示列表,顶点数组。 VBO为顶点缓冲区对象,用于存储顶点坐标/顶点uv/顶点法线/顶点颜色,也可以用于其他用途,比如tangent。 IBO为...
  • openGL的context 在openGL渲染管线中,context保存了当前的渲染状态,在OSG...openGL中的另一个重要概念是object,如VAO、VBO、IBO、TBO、FBO等等。这些object中要么存放的是原始数据,如顶点坐标、顶点颜色、纹...
  • 一个多月前,我写了一篇文章区块链4.0----通证...从RAM到NewDex, ET(去中心化交易所),BancorX及股权游戏,再到火爆的fibos和TpToken(IBO)。从自由兑换到锁仓,从投机到投资到和发行方一起成长,bancor正在不断演...
  • opengl中VAO,VBO,IBO用法小结 这三个玩意全面取代旧社会的glBegin/glEnd,显示列表,顶点数组。 VBO为顶点缓冲区对象,用于存储顶点坐标/顶点uv/顶点法线/顶点颜色,也可以用于其他用途,比如tangent。 IBO为...
  • opengl中VAO,VBO,IBO用法小结(zz)

    千次阅读 2014-07-24 19:50:59
    opengl中VAO,VBO,IBO用法小结 这三个玩意全面取代旧社会的glBegin/glEnd,显示列表,顶点数组。 VBO为顶点缓冲区对象,用于存储顶点坐标/顶点uv/顶点法线/顶点颜色,也可以用于其他用途,比如tangent。 IBO为...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 287
精华内容 114
关键字:

IBO