OpenGL VBO Interleaved and alternated - opengl

Question

I guess I'm expecting too much, but, maybe, it could be possible.
In python I do have a huge numpy array (with 2 point 2D lines), something like this:
[ [x1, y1, x2, y2, r, g, b, width],
[x1, y1, x2, y2, r, g, b, width],
.......
]
there is any way I can configure a VBO and shaders to process those lines?
I can't see how to do that since each "vector" actually has two vectors :)
My idea was to use a transparent vertex shader and then geometry shader to accept points (single vector), and then output two triangles (strip), to form the 2D line.
By the way: width can be a big number, that's why I'm planning to draw the line as two triangles.
Since I've never used a geometry shader before, I'm wondering if that's possible?

Answer 1

A geometry shader should be able to handle this. Since it's a little simpler, I'll illustrate it with drawing lines. If you read up more on geometry shaders, I'm sure you can figure out how to pass in the width, and generate triangles instead.
The basic idea is that you pass the [x1, y1, x2, y2] values as a single vec4 attribute into the vertex shader. Assuming that you already stored the data in a VBO, and have it bound as GL_ARRAY_BUFFER, you use this call:
glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, stride, 0);
For drawing, you use GL_POINTS as the primitive type, which you will later turn into lines in the geometry shader:
glDrawArrays(GL_POINTS, 0, lineCount);
Then in the vertex shader, you simply pass the position along:
in vec4 InPos;
...
gl_Position = InPos;
In the geometry shader, you will then use the first 2 components of the input vector, which are [x1, y1] as the first point of the line, and the second 2 components, which are [x2, y2], as the second point of the generated line:
layout (points) in;
layout (line_strip, max_vertices = 2) out;
void main() {
gl_Position = vec4(gl_in[0].gl_Position.xy, 0.0, 1.0);
EmitVertex();
gl_Position = vec4(gl_in[0].gl_Position.wz, 0.0, 1.0);
EmitVertex();
EndPrimitive();
}

Answer 2

I'm intentionally posting this as a second answer, since it's almost entirely different. This one does not use geometry shaders, but uses instanced rendering instead. It might be somewhat unconventional, but I can't think of a reason why it couldn't work.
The very first part is the same. You create a single 4-component vertex attribute that contains the coordinates of both 2D points, [x1, y1, x2, y2]. But this time, you also enable instanced rendering for the attribute:
glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, stride, 0);
glVertexAttribDivisor(loc, 1);
The second call specifies that the same attribute value is used for all vertices of each instance, and is only advanced per instance.
With this, we can now draw each line as a separate instance, with 2 vertices per instance:
glDrawArraysInstanced(GL_LINES, 0, 2, lineCount);
Now, the consequence of only advancing once per instance is that you will get the same attribute values for both vertices of each instance. This may look like a problem, but you can use gl_VertexID to pick the first two components for the first vertex, and the other two components for the second vertex:
in vec4 InPos;
...
gl_Position = vec4(InPos[gl_VertexID * 2], InPos[gl_VertexID * 2 + 1], 0.0, 1.0);
Since gl_VertexID will be 0, this will get components 0 and 1, corresponding to [x1, y1] for the first vertex, and components 2 and 3, corresponding to [x2, y2] for the second vertex of each line.