标签: vertex-array

我正在用C++编写一个程序,通过UDP套接字获取4维点数据,然后在6个独立的2D散点图中绘制数据.例如,如果我们命名尺寸:A,B,C,D六个2d图将是AxB,AxC,AxD,BxC,BxD和CxD.在几个小时的过程中,该计划累积了大约50K点.

目前,我使用立即模式绘制每个点一次.我没有清除绘制调用之间的缓冲区,因此先前绘制的点会一直存在,直到缓冲区被清除.我对这种方法不满意,因为立即模式很慢并且已弃用.当我必须清除缓冲区时,就像窗口重新调整大小时一样,我丢失了之前绘制的所有数据.我想提出一个解决方案,在清除缓冲区后允许数据持久化.此外,如果可以使用窗口重新调整大小来轻松缩放绘图,那将是很好的.

我已经考虑过为每个坐标系维护一个顶点数组(有2个维度),但这需要6个独立的数组,并且需要3倍的内存来维护一个包含所有4个维度的数组.

我是否以正确的方式思考这个问题？这个问题的正确解决方案是什么？

最终目标是让应用程序尽可能接近实时地显示数据.

编辑是否可以在它们进入时逐个绘制点,当我需要调整屏幕大小时抓取屏幕图像然后显示该图像的调整大小的版本？

我试图让我的渲染功能工作.我正在使用顶点数组.这是我的顶点结构.

struct Vertex 
{
    float x, y, z;              // The x, y and z floating point values     
    float u, v;                 // The u - v texture coordinates
    float padding[3];   // needs to be multiple of 32
};

这是我的渲染代码:

// Render the mesh
void WLD::render(GLuint* textures, long curRegion, CFrustum cfrustum)
{

    int num = 0;

    // Set up my indices
    GLuint indicies[3];

    // Cycle through the PVS
    while(num < regions[curRegion].visibility.size())
    {
        int i = regions[curRegion].visibility[num];

        if(!regions[i].dead && regions[i].meshptr != NULL)
        { …

我想在Android的native-c应用程序中使用VAO.

问题是,这GL_OES_vertex_array_object是支持的,我甚至可以得到的地址glBindVertexArrayOES和glDeleteVertexArraysOES,但glGenVertexArraysOES没有找到.

存在是否GL_OES_vertex_array_object可以访问所有这些功能？

我的VAO初始化代码:

std::string vao = "GL_OES_vertex_array_object";

if ( isExtensionSupported ( vao.c_str () ) != 0 )
{
    LOG ( vao << " supported" );
    glBindVertexArrayOES = (PFNGLBINDVERTEXARRAYOESPROC)eglGetProcAddress ( "glBindVertexArrayOES" );
    if ( !glBindVertexArrayOES )
        LOG ( "Can't get proc address: glBindVertexArrayOES" );

    glDeleteVertexArraysOES = (PFNGLDELETEVERTEXARRAYSOESPROC)eglGetProcAddress ( "glDeleteVertexArraysOES" );
    if ( !glDeleteVertexArraysOES )
        LOG ( "Can't get proc address: glDeleteVertexArraysOES" );

    glGenVertexArraysOES = (PFNGLGENVERTEXARRAYSOESPROC)eglGetProcAddress ( "glGenVertexArraysOES" );
    if ( …

我有一个调用glDrawArrays的OpenGL渲染代码,当OpenGL上下文(自动/隐式获取)时,它可以完美地运行4.2但是在显式请求的OpenGL核心上下文3.2中一致地失败(GL_INVALID_OPERATION).(在两种情况下,着色器始终设置为#version 150,但这与我怀疑的点不同.)

根据规范,glDrawArrays()在GL_INVALID_OPERATION失败时只有两个实例:

• "如果非零缓冲区对象名称绑定到已启用的数组,并且缓冲区对象的数据存储当前已映射" - 此时我没有进行任何缓冲区映射

• "如果几何着色器处于活动状态且模式与[...]不兼容" - nope,则截至目前没有几何着色器.

此外:

1. 我已经验证并仔细检查了它只是glDrawArrays()调用失败了.还要仔细检查传递给glDrawArrays()的所有参数在GL版本,缓冲区绑定下是否相同.

2. 这发生在3个不同的nvidia GPU和2个不同的操作系统(Win7和OSX,都是64位 - 当然,在OSX中我们只有 3.2上下文,无论如何都不是4.2).

3. 使用集成的"Intel HD"GPU不会发生这种情况,但对于那个,我只获得一个自动的隐式3.3上下文(试图通过GLFW明确强制使用此GPU的3.2核心配置文件在这里无法创建窗口,但这是一个完全不同的问题...)

对于它的价值,这里是在Golang中从渲染循环中摘录的相关例程:

func (me *TMesh) render () {
    curMesh = me
    curTechnique.OnRenderMesh()
    gl.BindBuffer(gl.ARRAY_BUFFER, me.glVertBuf)
    if me.glElemBuf > 0 {
        gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, me.glElemBuf)
        gl.VertexAttribPointer(curProg.AttrLocs["aPos"], 3, gl.FLOAT, gl.FALSE, 0, gl.Pointer(nil))
        gl.DrawElements(me.glMode, me.glNumIndices, gl.UNSIGNED_INT, gl.Pointer(nil))
        gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0)
    } else {
        gl.VertexAttribPointer(curProg.AttrLocs["aPos"], 3, gl.FLOAT, gl.FALSE, 0, gl.Pointer(nil))
        /* BOOM! */
        gl.DrawArrays(me.glMode, 0, me.glNumVerts)
    }
    gl.BindBuffer(gl.ARRAY_BUFFER, 0)
}

所以当然这是更大的渲染循环的一部分,尽管现在整个"*TMesh"构造只是两个实例,一个是简单的立方体,另一个是简单的金字塔.重要的是整个绘图循环完美无缺,在3.3和4.2下查询GL时没有报告错误,但是3个具有显式3.2核心配置文件的nvidia GPU失败并且错误代码根据规范只调用了两个具体情况,据我所知,这里没有一个适用.

这可能有什么问题？你碰到过这个吗？我缺少什么想法？

我想尝试制作一个像下图中右边的三角形:

问题是我想要实现的是来自C的顶点1和2的颜色渐变.

据我所知这是不可能的,因为顶点C必须有自己的颜色,它也会混合成1和2的颜色,就像图片的左三角形一样.如果我将C设置为中间点颜色,则会产生不希望的结果,因为制作三角形越高,其他顶点的颜色就越不明显.

线C1应为黑色,线C2应为白色.

有没有办法在OpenGL中实现这一目标？

我正在开发一个个人Java OpenGL(JOGL)项目,我正在使用一些带有独立绘图函数和顶点的自定义对象.

public class Cube extends PhysicalObject {

 public void draw(GL gl) {

         gl.glColor3f(1.0f, 1.0f, 0.0f);

         gl.glEnableClientState(GL.GL_VERTEX_ARRAY);  // Enable Vertex Arrays

            gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);  

            gl.glVertexPointer(3, GL.GL_FLOAT, 0, vertices); 

            gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, texCoords); 

            gl.glDrawArrays(GL.GL_QUADS, 0, 4*6);  


            gl.glDisableClientState(GL.GL_VERTEX_ARRAY);  

            gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY); 

}

然后我循环遍历一大堆这些立方体,调用它们的绘图函数.我的问题如下:我应该将所有顶点收集到一个大的glDrawArrays调用,即将所有顶点收集到一个大数组并绘制它？它对性能和fps有多大帮助？

我在每个渲染上动态生成顶点数组,然后我想删除数组.是否glDrawArrays立即将顶点数组复制到服务器？因此在调用后删除顶点数组是否安全glDrawArrays？

float * vp = GetVertices(); // Regenerated on each render
glVertexPointer(3, GL_FLOAT, 3 * sizeof(float), vp);
glDrawArrays(GL_TRIANGLES, 0, nVertices);
delete[] vp; // Can I do this?

否则,如何确定何时删除顶点数组是否安全？

在终端中使用ndk-build编译以下C代码时(我正在运行Ubuntu):

#include <jni.h>

#include <GLES/gl.h>
#include <GLES/glext.h>

#include "org_opengldrawinjni_DrawinJNI.h"


JNIEXPORT void JNICALL Java_org_opengldrawinjni_DrawinJNI_Draw
  (JNIEnv *envptr, jobject jobj)
{
 GLfloat vertices[] =
  { 1.0, 0.0, 0.0,
    1.0, 1.0, 0.0,
    0.0, 0.0, 0.0
  };
 GLubyte indices[] = { 0, 1, 2 };
 glVertexPointer(3, GL_FLOAT, 0, vertices);
 glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_BYTE, indices);
}

使用此Android.mk文件:

   LOCAL_PATH := $(call my-dir)

   include $(CLEAR_VARS)

   LOCAL_MODULE    := OpenGLJNI
   LOCAL_SRC_FILES := org_opengldrawinjni_DrawinJNI.c
   LOCAL_LDLIBS := -llog -lGLESv1_CM.so

   include $(BUILD_SHARED_LIBRARY)

我得到一个错误,未定义的glVertexPointer引用.我想知道为什么,因为我相信我正确地包含了标题并链接了Android.mk中的库

/home/thomas/Documents/LinuxProgramming/EclipseWorkspace/OpenGLDrawinginJNI/obj/local/armeabi/objs/OpenGLJNI/org_opengldrawinjni_DrawinJNI.o: In function `Java_org_opengldrawinjni_DrawinJNI_Draw':
/home/thomas/Documents/LinuxProgramming/EclipseWorkspace/OpenGLDrawinginJNI/jni/org_opengldrawinjni_DrawinJNI.c:33: undefined reference to `glVertexPointer'
collect2: ld …

伪代码:

void draw()
{
    Vertex* vertices = scene.GetVertexArray();
    glEnableClientState(...);
    glVertexPointer(..., vertices);
    glDrawArrays(...);
    glDisableClientState(...);
    delete vertices;
}

我不使用VBO,因为我想支持较旧的OpenGL实现.

在调用glDrawArrays之后,我想:

• 解除分配我的顶点数组(" delete vertices;")
• 也许修改一些顶点

但是,GL可以自由地异步执行glDrawArrays,并且在完成之前解除分配或修改我的数组是不安全的.

我可以做一个glFinish来确保,但它会减慢应用程序的速度.

那么在什么时候我可以自由地解除分配/修改我的顶点数组？

我正在开发一款iOS游戏,需要一次渲染500-800个粒子.我已经了解到,在OpenGL ES中批量渲染许多精灵而不是glDrawArrays(..)在游戏中调用每个精灵是一个好主意,以便能够渲染更多的精灵而不会大幅降低帧速率.

我的问题是:如何批量渲染500多个粒子,这些粒子都具有不同的alphas,旋转和比例,但共享相同的纹理图集？这个问题的重点是每个粒子的不同 alphas,旋转和比例.

我意识到这个问题非常类似于如何在iPhone OpenGL ES粒子系统中绘制1000多个粒子(具有独特的旋转,缩放和alpha)而不会减慢游戏速度？但是,该问题不涉及批量渲染.在利用顶点缓冲区对象之前,我想了解OpenGL ES中的批渲染与唯一的alphas,旋转和缩放(但具有相同的纹理).因此,虽然我计划最终使用VBO,但我想先采用这种方法.

代码示例将非常受欢迎,如果您使用索引数组作为一些示例,请解释索引数组的结构和目的.

编辑我正在使用OpenGL ES 1.1.

编辑下面是我如何渲染场景中每个粒子的代码示例.假设它们共享相同的纹理,并且在此代码执行之前该纹理已经在OpenGL ES 1.1中绑定.

- (void) render {

    glPushMatrix();

    glTranslatef(translation.x, translation.y, translation.z);

    glRotatef(rotation.x, 1, 0, 0);
    glRotatef(rotation.y, 0, 1, 0);
    glRotatef(rotation.z, 0, 0, 1);

    glScalef(scale.x, scale.y, scale.z);

    // change alpha
    glColor4f(1.0, 1.0, 1.0, alpha);

    // glBindTexture(GL_TEXTURE_2D, texture[0]);

    glVertexPointer(2, GL_FLOAT, 0, texturedQuad.vertices);
    glEnableClientState(GL_VERTEX_ARRAY);


    glTexCoordPointer(2, GL_FLOAT, 0, texturedQuad.textureCoords);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glPopMatrix();
} …

我正试图摆脱立即模式,因为我不断被告知它真的不是在Opengl中编程的最佳方式.我找到了一个教程,它将制作一个立方体并为其着色,但它不包括纹理.

这是我的代码:

GLfloat vertices[] = { 1, 1, 1,  -1, 1, 1,  -1,-1, 1,   1,-1, 1,   // v0,v1,v2,v3 (front)
                        1, 1, 1,   1,-1, 1,   1,-1,-1,   1, 1,-1,   // v0,v3,v4,v5 (right)
                        1, 1, 1,   1, 1,-1,  -1, 1,-1,  -1, 1, 1,   // v0,v5,v6,v1 (top)
                       -1, 1, 1,  -1, 1,-1,  -1,-1,-1,  -1,-1, 1,   // v1,v6,v7,v2 (left)
                       -1,-1,-1,   1,-1,-1,   1,-1, 1,  -1,-1, 1,   // v7,v4,v3,v2 (bottom)
                        1,-1,-1,  -1,-1,-1,  -1, 1,-1,   1, 1,-1 }; // v4,v7,v6,v5 (back)

// normal array
GLfloat normals[]  = { …

当尝试使用顶点数组(而不是使用立即模式渲染)在OpenGL中绘制以下四边形时,我得到图片中显示的图形毛刺(线段),可以在下面的第二个链接中找到.这条线似乎向上延伸到无穷大.

GLdouble vertices[] = {
    // back
    0.0, 0.0, 0.0,
    si,  0.0, 0.0,
    si,  -si, 0.0,
    0.0, -si, 0.0,

    // front
    0.0, 0.0, si,
    0.0, -si, si,
    si,  -si, si,
    si,  0.0, si,

    // left
    0.0, 0.0, 0.0,
    0.0, -si, 0.0,
    0.0, -si, si,
    0.0, 0.0, si,

    // right
    si, 0.0, 0.0,
    si, 0.0, si,
    si, -si, si,
    si, -si, 0.0,

    // top
    0.0, 0.0, 0.0,
    0.0, 0.0, si,
    si, 0.0, si,
    si, 0.0, 0.0,

    // bottom
    0.0, -si, 0.0, …

我知道当调用glDrawElements时,它使用索引缓冲区来确定以什么顺序绘制的顶点.我的问题是这些索引如何应用于纹理,法线和颜色属性.是否可以设置另一个索引数组,以确定每个顶点应使用哪个纹理坐标和法线.或者我是否必须创建法线和纹理坐标缓冲区,以便它们与正在绘制的顶点对齐？