Support element / index buffers in VAOs

Author: einarf

demosys/opengl/geometry/plane.py

@@ -16,33 +16,111 @@ def plane_xz(size=(10, 10), resolution=(10, 10)):
     dx, dz = sx / rx, sz / rz  # step
     ox, oz = -sx / 2, -sz / 2  # start offset
 
-    def vertex(x, z):
-        yield ox + x * dx
-        yield 0
-        yield oz + z * dz
-
-    def gen():
-        up = True
-        for x in range(rx):
-            if up:
-                # Generate strip upwards
-                for z in reversed(range(rz)):
-                    yield from vertex(x, z)
-                    yield from vertex(x + 1, z)
-            else:
-                # Generate strip downwards
-                for z in range(rz - 1):
-                    yield from vertex(x + 1, z)
-                    yield from vertex(x, z + 1)
-
-            up = not up  # toggle strip direction
-
-    # FIXME: Calculate the actual size (count=rx * rz * 3 * 2)
-    data = numpy.fromiter(gen(), dtype=numpy.float32)
-    position_vbo = VBO(data)
-
-    vao = VAO("plane_xz", mode=GL.GL_TRIANGLE_STRIP)
+    def gen_pos():
+        for z in range(rz):
+            for x in range(rx):
+                yield ox + x * dx
+                yield 0
+                yield oz + z * dz
+
+    def gen_uv():
+        for z in range(rz):
+            for x in range(rx):
+                yield x / (rx - 1)
+                yield 1 - z / (rz - 1)
+
+    def gen_index():
+        for z in range(rz - 1):
+            for x in range(rx - 1):
+                # quad poly left
+                yield z * rz + x
+                yield z * rz + x + 1
+                yield z * rz + x + rx
+                # quad poly right
+                yield z * rz + x + rx
+                yield z * rz + x + 1
+                yield z * rz + x + rx + 1
+
+    pos_data = numpy.fromiter(gen_pos(), dtype=numpy.float32)
+    position_vbo = VBO(pos_data)
+
+    uv_data = numpy.fromiter(gen_uv(), dtype=numpy.float32)
+    uv_vbo = VBO(uv_data)
+
+    index_data = numpy.fromiter(gen_index(), dtype=numpy.int32)
+    index_vbo = VBO(index_data, target=GL.GL_ELEMENT_ARRAY_BUFFER)
+
+    vao = VAO("plane_xz", mode=GL.GL_TRIANGLES)
     vao.add_array_buffer(GL.GL_FLOAT, position_vbo)
+    vao.add_array_buffer(GL.GL_FLOAT, uv_vbo)
     vao.map_buffer(position_vbo, "in_position", 3)
+    vao.map_buffer(uv_vbo, "in_uv", 2)
+    vao.set_element_buffer(GL.GL_UNSIGNED_INT, index_vbo)
     vao.build()
     return vao
+
+
+# def plane_xz(size=(10, 10), resolution=(10, 10)):
+#     """
+#     Generates a plane on the xz axis of a specific size and resolution
+#     :param size: (x, y) tuple
+#     :param resolution: (x, y) tuple
+#     :return: VAO
+#     """
+#     sx, sz = size
+#     rx, rz = resolution
+#     dx, dz = sx / rx, sz / rz  # step
+#     ox, oz = -sx / 2, -sz / 2  # start offset
+#
+#     def vertex(x, z):
+#         yield ox + x * dx
+#         yield 0
+#         yield oz + z * dz
+#
+#     def uv(x, z):
+#         yield x * 1 / rx
+#         yield z * 1 / rz
+#
+#     def gen_pos():
+#         up = True
+#         for x in range(rx):
+#             if up:
+#                 # Generate strip upwards
+#                 for z in reversed(range(rz)):
+#                     yield from vertex(x, z)
+#                     yield from vertex(x + 1, z)
+#             else:
+#                 # Generate strip downwards
+#                 for z in range(rz - 1):
+#                     yield from vertex(x + 1, z)
+#                     yield from vertex(x, z + 1)
+#
+#             up = not up  # toggle strip direction
+#
+#     def gen_uv():
+#         up = True
+#         for x in range(rx):
+#             if up:
+#                 # Generate strip upwards
+#                 for z in range(rz):
+#                     yield from uv(x, z)
+#                     yield from uv(x + 1, z)
+#             else:
+#                 # Generate strip downwards
+#                 for z in range(rz - 1):
+#                     yield from uv(x + 1, z)
+#                     yield from uv(x, z + 1)
+#
+#     pos_data = numpy.fromiter(gen_pos(), dtype=numpy.float32)
+#     position_vbo = VBO(pos_data)
+#
+#     uv_data = numpy.fromiter(gen_uv(), dtype=numpy.float32)
+#     uv_vbo = VBO(uv_data)
+#
+#     vao = VAO("plane_xz", mode=GL.GL_TRIANGLE_STRIP)
+#     vao.add_array_buffer(GL.GL_FLOAT, position_vbo)
+#     vao.add_array_buffer(GL.GL_FLOAT, uv_vbo)
+#     vao.map_buffer(position_vbo, "in_position", 3)
+#     vao.map_buffer(uv_vbo, "in_uv", 2)
+#     vao.build()
+#     return vao

demosys/opengl/vao.py

@@ -91,11 +91,21 @@ def draw(self, mode=None):
         :param mode: Override the default GL_TRIANGLES
         """
         if self.element_buffer:
-            raise NotImplemented
-        if mode is not None:
-            GL.glDrawArrays(mode, 0, self.vertex_count)
+            if mode is not None:
+                GL.glDrawElements(mode,
+                                  self.element_buffer.size,
+                                  self.element_buffer.format,
+                                  self.element_buffer.vbo)
+            else:
+                GL.glDrawElements(self.mode,
+                                  self.element_buffer.size,
+                                  self.element_buffer.format,
+                                  self.element_buffer.vbo)
         else:
-            GL.glDrawArrays(self.mode, 0, self.vertex_count)
+            if mode is not None:
+                GL.glDrawArrays(mode, 0, self.vertex_count)
+            else:
+                GL.glDrawArrays(self.mode, 0, self.vertex_count)
 
     def add_array_buffer(self, format, vbo):
         self.array_buffer_map[id(vbo)] = ArrayBuffer(format, vbo)
@@ -186,6 +196,9 @@ def generate_vao_combo(self, shader):
                 raise VAOError("VAO class have not implemented array binding for {}".format(
                     mapping.array_buffer.format))
 
+        if self.element_buffer:
+            self.element_buffer.vbo.bind()
+
         self.combos[shader.attribute_key] = combo
         GL.glBindVertexArray(0)
         return combo