vispy 0.9.5__cp38-cp38-win_amd64.whl → 0.14.0__cp38-cp38-win_amd64.whl

vispy/geometry/meshdata.py

@@ -19,6 +19,56 @@ def _fix_colors(colors):
     return colors
 
 
+def _compute_face_normals(vertices):
+    if vertices.shape[1:] != (3, 3):
+        raise ValueError("Expected (N, 3, 3) array of vertices repeated on"
+                         f" the triangle corners, got {vertices.shape}.")
+    edges1 = vertices[:, 1] - vertices[:, 0]
+    edges2 = vertices[:, 2] - vertices[:, 0]
+    return np.cross(edges1, edges2)
+
+
+def _repeat_face_normals_on_corners(normals):
+    if normals.shape[1:] != (3,):
+        raise ValueError("Expected (F, 3) array of face normals, got"
+                         f" {normals.shape}.")
+    n_corners_in_face = 3
+    new_shape = (normals.shape[0], n_corners_in_face, normals.shape[1])
+    return np.repeat(normals, n_corners_in_face, axis=0).reshape(new_shape)
+
+
+def _compute_vertex_normals(face_normals, faces, vertices):
+    if face_normals.shape[1:] != (3,):
+        raise ValueError("Expected (F, 3) array of face normals, got"
+                         f" {face_normals.shape}.")
+    if faces.shape[1:] != (3,):
+        raise ValueError("Expected (F, 3) array of face vertex indices, got"
+                         f" {faces.shape}.")
+    if vertices.shape[1:] != (3,):
+        raise ValueError("Expected (N, 3) array of vertices, got"
+                         f" {vertices.shape}.")
+
+    vertex_normals = np.zeros_like(vertices)
+    n_corners_in_triangle = 3
+    face_normals_repeated_on_corners = np.repeat(face_normals,
+                                                 n_corners_in_triangle,
+                                                 axis=0)
+    # NOTE: The next line is equivalent to
+    #
+    #   vertex_normals[self._faces.ravel()] += face_normals_repeated_on_corners
+    #
+    # except that it accumulates the values from the right hand side at
+    # repeated indices on the left hand side, instead of overwritting them,
+    # like in the above.
+    np.add.at(vertex_normals, faces.ravel(), face_normals_repeated_on_corners)
+
+    norms = np.sqrt((vertex_normals**2).sum(axis=1))
+    nonzero_norms = norms > 0
+    vertex_normals[nonzero_norms] /= norms[nonzero_norms][:, None]
+
+    return vertex_normals
+
+
 class MeshData(object):
     """
     Class for storing and operating on 3D mesh data.
@@ -141,7 +191,7 @@ class MeshData(object):
                 self._compute_edges(indexed='faces')
             return self._edges_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def set_faces(self, faces):
         """Set the faces
@@ -191,7 +241,7 @@ class MeshData(object):
                     self._vertices[self.get_faces()]
             return self._vertices_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def get_bounds(self):
         """Get the mesh bounds
@@ -234,7 +284,7 @@ class MeshData(object):
             if verts is not None:
                 self._vertices_indexed_by_faces = verts
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
         if reset_normals:
             self.reset_normals()
@@ -293,22 +343,19 @@ class MeshData(object):
         normals : ndarray
             The normals.
         """
+        if indexed not in (None, 'faces'):
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
+
         if self._face_normals is None:
-            v = self.get_vertices(indexed='faces')
-            self._face_normals = np.cross(v[:, 1] - v[:, 0],
-                                          v[:, 2] - v[:, 0])
+            vertices = self.get_vertices(indexed='faces')
+            self._face_normals = _compute_face_normals(vertices)
 
-        if indexed is None:
-            return self._face_normals
-        elif indexed == 'faces':
-            if self._face_normals_indexed_by_faces is None:
-                norms = np.empty((self._face_normals.shape[0], 3, 3),
-                                 dtype=np.float32)
-                norms[:] = self._face_normals[:, np.newaxis, :]
-                self._face_normals_indexed_by_faces = norms
-            return self._face_normals_indexed_by_faces
-        else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+        if indexed == 'faces' and self._face_normals_indexed_by_faces is None:
+            self._face_normals_indexed_by_faces = \
+                _repeat_face_normals_on_corners(self._face_normals)
+
+        return (self._face_normals if indexed is None
+                else self._face_normals_indexed_by_faces)
 
     def get_vertex_normals(self, indexed=None):
         """Get vertex normals
@@ -326,29 +373,20 @@ class MeshData(object):
         normals : ndarray
             The normals.
         """
+        if indexed not in (None, 'faces'):
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
+
         if self._vertex_normals is None:
-            faceNorms = self.get_face_normals()
-            vertFaces = self.get_vertex_faces()
-            self._vertex_normals = np.empty(self._vertices.shape,
-                                            dtype=np.float32)
-            for vindex in range(self._vertices.shape[0]):
-                faces = vertFaces[vindex]
-                if len(faces) == 0:
-                    self._vertex_normals[vindex] = (0, 0, 0)
-                    continue
-                norms = faceNorms[faces]  # get all face normals
-                norm = norms.sum(axis=0)  # sum normals
-                renorm = (norm**2).sum()**0.5
-                if renorm > 0:
-                    norm /= renorm
-                self._vertex_normals[vindex] = norm
+            face_normals = self.get_face_normals()
+            faces = self.get_faces()
+            vertices = self.get_vertices()
+            self._vertex_normals = _compute_vertex_normals(face_normals, faces,
+                                                           vertices)
 
         if indexed is None:
             return self._vertex_normals
         elif indexed == 'faces':
             return self._vertex_normals[self.get_faces()]
-        else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
 
     def get_vertex_colors(self, indexed=None):
         """Get vertex colors
@@ -373,7 +411,7 @@ class MeshData(object):
                     self._vertex_colors[self.get_faces()]
             return self._vertex_colors_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def get_vertex_values(self, indexed=None):
         """Get vertex colors
@@ -398,7 +436,7 @@ class MeshData(object):
                     self._vertex_values[self.get_faces()]
             return self._vertex_values_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def set_vertex_colors(self, colors, indexed=None):
         """Set the vertex color array
@@ -488,7 +526,7 @@ class MeshData(object):
                     self._face_colors.reshape(Nf, 1, 4)
             return self._face_colors_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def set_face_colors(self, colors, indexed=None):
         """Set the face color array
@@ -611,7 +649,7 @@ class MeshData(object):
                 raise Exception("MeshData cannot generate edges--no faces in "
                                 "this data.")
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def save(self):
         """Serialize this mesh to a string appropriate for disk storage

vispy/geometry/rect.py

@@ -113,6 +113,12 @@ class Rect(object):
         return (self.pos[0] + self.size[0] * 0.5,
                 self.pos[1] + self.size[1] * 0.5)
 
+    @center.setter
+    def center(self, value):
+        delta_x = value[0] - self.center[0]
+        delta_y = value[1] - self.center[1]
+        self.pos = (self.pos[0] + delta_x, self.pos[1] + delta_y)
+
     def padded(self, padding):
         """Return a new Rect padded (smaller) by padding on all sides
 

vispy/geometry/tests/test_meshdata.py

@@ -31,4 +31,76 @@ def test_meshdata():
     assert_array_equal(square_edges, mesh.get_edges())
 
 
+def test_vertex_normals_indexed_none():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    vertex_normals_unnormalized = np.array(
+        [[-1, -1, -1], [0, -1, -1], [-1, 0, -1], [-1, -1, 0]],
+        dtype=dtype_float)
+    norms = np.sqrt((vertex_normals_unnormalized**2).sum(axis=1,
+                                                         keepdims=True))
+    expected_vertex_normals = vertex_normals_unnormalized / norms
+
+    computed_vertex_normals = mesh.get_vertex_normals(indexed=None)
+
+    assert_array_equal(expected_vertex_normals, computed_vertex_normals)
+
+
+def test_vertex_normals_indexed_faces():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    vertex_normals_unnormalized = np.array(
+        [[-1, -1, -1], [0, -1, -1], [-1, 0, -1], [-1, -1, 0]],
+        dtype=dtype_float)
+    norms = np.sqrt((vertex_normals_unnormalized**2).sum(axis=1,
+                                                         keepdims=True))
+    vertex_normals = vertex_normals_unnormalized / norms
+    expected_vertex_normals = vertex_normals[faces]
+
+    computed_vertex_normals = mesh.get_vertex_normals(indexed="faces")
+
+    assert_array_equal(expected_vertex_normals, computed_vertex_normals)
+
+
+def test_face_normals_indexed_none():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    expected_face_normals = np.array([[0, 0, -1], [-1, 0, 0], [0, -1, 0]],
+                                     dtype=dtype_float)
+
+    computed_face_normals = mesh.get_face_normals(indexed=None)
+
+    assert_array_equal(expected_face_normals, computed_face_normals)
+
+
+def test_face_normals_indexed_faces():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    expected_face_normals = np.array([
+        [[0, 0, -1], [0, 0, -1], [0, 0, -1]],
+        [[-1, 0, 0], [-1, 0, 0], [-1, 0, 0]],
+        [[0, -1, 0], [0, -1, 0], [0, -1, 0]]],
+        dtype=dtype_float)
+
+    computed_face_normals = mesh.get_face_normals(indexed="faces")
+
+    assert_array_equal(expected_face_normals, computed_face_normals)
+
+
 run_tests_if_main()

vispy/gloo/buffer.py

@@ -414,6 +414,10 @@ class VertexBuffer(DataBuffer):
         Buffer data (optional)
     """
 
+    def __init__(self, data=None, divisor=None):
+        super().__init__(data)
+        self.divisor = divisor
+
     _GLIR_TYPE = 'VertexBuffer'
 
     def _prepare_data(self, data, convert=False):
@@ -449,6 +453,14 @@ class VertexBuffer(DataBuffer):
             self._last_dim = c
         return data
 
+    @property
+    def divisor(self):
+        return self._divisor
+
+    @divisor.setter
+    def divisor(self, value):
+        self._divisor = max(1, int(value)) if value else None
+
 
 def _last_stack_str():
     """Print stack trace from call that didn't originate from here"""

vispy/gloo/gl/_constants.py

@@ -1,4 +1,4 @@
-"""
+"""GL definitions converted to Python by codegen/createglapi.py.
 
 THIS CODE IS AUTO-GENERATED. DO NOT EDIT.
 
@@ -8,11 +8,13 @@ Constants for OpenGL ES 2.0.
 
 
 class Enum(int):
-    ''' Enum (integer) with a meaningfull repr. '''
+    """Enum (integer) with a meaningfull repr."""
+    
     def __new__(cls, name, value):
         base = int.__new__(cls, value)
         base.name = name
         return base
+        
     def __repr__(self):
         return self.name
 
@@ -149,6 +151,7 @@ GL_LOW_FLOAT = Enum('GL_LOW_FLOAT', 36336)
 GL_LOW_INT = Enum('GL_LOW_INT', 36339)
 GL_LUMINANCE = Enum('GL_LUMINANCE', 6409)
 GL_LUMINANCE_ALPHA = Enum('GL_LUMINANCE_ALPHA', 6410)
+GL_MAX = Enum('GL_MAX', 32776)
 GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = Enum('GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS', 35661)
 GL_MAX_CUBE_MAP_TEXTURE_SIZE = Enum('GL_MAX_CUBE_MAP_TEXTURE_SIZE', 34076)
 GL_MAX_FRAGMENT_UNIFORM_VECTORS = Enum('GL_MAX_FRAGMENT_UNIFORM_VECTORS', 36349)
@@ -162,6 +165,7 @@ GL_MAX_VERTEX_UNIFORM_VECTORS = Enum('GL_MAX_VERTEX_UNIFORM_VECTORS', 36347)
 GL_MAX_VIEWPORT_DIMS = Enum('GL_MAX_VIEWPORT_DIMS', 3386)
 GL_MEDIUM_FLOAT = Enum('GL_MEDIUM_FLOAT', 36337)
 GL_MEDIUM_INT = Enum('GL_MEDIUM_INT', 36340)
+GL_MIN = Enum('GL_MIN', 32775)
 GL_MIRRORED_REPEAT = Enum('GL_MIRRORED_REPEAT', 33648)
 GL_NEAREST = Enum('GL_NEAREST', 9728)
 GL_NEAREST_MIPMAP_LINEAR = Enum('GL_NEAREST_MIPMAP_LINEAR', 9986)
@@ -322,7 +326,7 @@ GL_ZERO = Enum('GL_ZERO', 0)
 
 
 ENUM_MAP = {}
-for ob in list(globals().values()):
-    if repr(ob).startswith('GL_'):
+for var_name, ob in list(globals().items()):
+    if var_name.startswith('GL_'):
         ENUM_MAP[int(ob)] = ob
-del ob
+del ob, var_name

vispy/gloo/gl/_es2.py

@@ -1,5 +1,10 @@
-"""THIS CODE IS AUTO-GENERATED. DO NOT EDIT.
-GL ES 2.0 API (via Angle/DirectX on Windows)"""
+"""GL definitions converted to Python by codegen/createglapi.py.
+
+THIS CODE IS AUTO-GENERATED. DO NOT EDIT.
+
+GL ES 2.0 API (via Angle/DirectX on Windows)
+
+"""
 
 import ctypes
 from .es2 import _lib
@@ -81,8 +86,7 @@ def glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha):
 _lib.glBufferData.argtypes = ctypes.c_uint, ctypes.c_ssize_t, ctypes.c_void_p, ctypes.c_uint,
 # void = glBufferData(GLenum target, GLsizeiptr size, GLvoid* data, GLenum usage)
 def glBufferData(target, data, usage):
-    """ Data can be numpy array or the size of data to allocate.
-    """
+    """Data can be numpy array or the size of data to allocate."""
     if isinstance(data, int):
         size = data
         data = ctypes.c_voidp(0)

vispy/gloo/gl/_gl2.py

@@ -1,4 +1,4 @@
-"""
+"""GL definitions converted to Python by codegen/createglapi.py.
 
 THIS CODE IS AUTO-GENERATED. DO NOT EDIT.
 
@@ -121,8 +121,7 @@ def glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha):
 
 # void = glBufferData(GLenum target, GLsizeiptr size, GLvoid* data, GLenum usage)
 def glBufferData(target, data, usage):
-    """ Data can be numpy array or the size of data to allocate.
-    """
+    """Data can be numpy array or the size of data to allocate."""
     if isinstance(data, int):
         size = data
         data = ctypes.c_voidp(0)

vispy/gloo/gl/_proxy.py

@@ -1,4 +1,4 @@
-"""
+"""GL definitions converted to Python by codegen/createglapi.py.
 
 THIS CODE IS AUTO-GENERATED. DO NOT EDIT.
 

vispy/gloo/gl/_pyopengl2.py

@@ -1,5 +1,10 @@
-"""THIS CODE IS AUTO-GENERATED. DO NOT EDIT.
-Proxy API for GL ES 2.0 subset, via the PyOpenGL library."""
+"""GL definitions converted to Python by codegen/createglapi.py.
+
+THIS CODE IS AUTO-GENERATED. DO NOT EDIT.
+
+Proxy API for GL ES 2.0 subset, via the PyOpenGL library.
+
+"""
 
 import ctypes
 from OpenGL import GL
@@ -34,24 +39,24 @@ def glCompressedTexImage2D(target, level, internalformat, width, height, border,
     size = data.size
     GL.glCompressedTexImage2D(target, level, internalformat, width, height, border, size, data)
 
-    
+
 def glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, data):
     size = data.size
     GL.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, size, data)
 
-    
+
 def glDeleteBuffer(buffer):
     GL.glDeleteBuffers(1, [buffer])
 
-    
+
 def glDeleteFramebuffer(framebuffer):
     FBO.glDeleteFramebuffers(1, [framebuffer])
 
-    
+
 def glDeleteRenderbuffer(renderbuffer):
     FBO.glDeleteRenderbuffers(1, [renderbuffer])
 
-    
+
 def glDeleteTexture(texture):
     GL.glDeleteTextures([texture])
 

vispy/gloo/gl/tests/test_names.py

@@ -234,6 +234,9 @@ GL_VERTEX_ATTRIB_ARRAY_SIZE GL_VERTEX_ATTRIB_ARRAY_STRIDE
 GL_VERTEX_ATTRIB_ARRAY_TYPE GL_VERTEX_SHADER GL_VIEWPORT GL_ZERO
 """.replace('\n', ' ')
 
+# vispy_ext.h
+constant_names += "GL_MIN GL_MAX"
+
 function_names = [n.strip() for n in function_names.split(' ')]
 function_names = set([n for n in function_names if n])
 constant_names = [n.strip() for n in constant_names.split(' ')]

vispy/gloo/glir.py

@@ -173,11 +173,13 @@ DRAW
 
 ::
 
-   ('DRAW', <program_id>, <mode:str>, <selection:tuple>)
-   # Example: Draw 100 lines
-   ('DRAW', 4, 'lines', (0, 100))
+   ('DRAW', <program_id>, <mode:str>, <selection:tuple>, <instances:int>)
+   # Example: Draw 100 lines with non-instanced rendering
+   ('DRAW', 4, 'lines', (0, 100), 1)
    # Example: Draw 100 lines using index buffer with id 5
-   ('DRAW', 4, 'points', (5, 'unsigned_int', 100))
+   ('DRAW', 4, 'points', (5, 'unsigned_int', 100), 1)
+   # Example: Draw a mesh with 10 vertices 20 times using instanced rendering
+   ('DRAW', 2, 'mesh', (0, 10), 20)
 
 Applies to: Program
 
@@ -362,7 +364,7 @@ import sys
 import re
 import json
 import weakref
-from distutils.version import LooseVersion
+from packaging.version import Version
 
 import numpy as np
 
@@ -371,6 +373,9 @@ from ..util import logger
 
 # TODO: expose these via an extension space in .gl?
 _internalformats = [
+    gl.Enum('GL_DEPTH_COMPONENT', 6402),
+    gl.Enum('GL_DEPTH_COMPONENT16', 33189),
+    gl.Enum('GL_DEPTH_COMPONENT32_OES', 33191),
     gl.Enum('GL_RED', 6403),
     gl.Enum('GL_R', 8194),
     gl.Enum('GL_R8', 33321),
@@ -847,7 +852,7 @@ class GlirParser(BaseGlirParser):
             if not this_version:
                 logger.warning("OpenGL version could not be determined, which "
                                "might be a sign that OpenGL is not loaded correctly.")
-            elif LooseVersion(this_version) < '2.1':
+            elif Version(this_version) < Version('2.1'):
                 if os.getenv('VISPY_IGNORE_OLD_VERSION', '').lower() != 'true':
                     logger.warning('OpenGL version 2.1 or higher recommended, '
                                    'got %s. Some functionality may fail.'
@@ -1220,7 +1225,7 @@ class GlirProgram(GlirObject):
             # Regular uniform
             func(handle, count, value)
 
-    def set_attribute(self, name, type_, value):
+    def set_attribute(self, name, type_, value, divisor=None):
         """Set an attribute value. Value is assumed to have been checked."""
         if not self._linked:
             raise RuntimeError('Cannot set attribute when program has no code')
@@ -1247,7 +1252,7 @@ class GlirProgram(GlirObject):
             funcname = self.ATYPEMAP[type_]
             func = getattr(gl, funcname)
             # Set data
-            self._attributes[name] = 0, handle, func, value[1:]
+            self._attributes[name] = 0, handle, func, value[1:], divisor
         else:
             # Get meta data
             vbo_id, stride, offset = value
@@ -1261,7 +1266,7 @@ class GlirProgram(GlirObject):
             # Set data
             func = gl.glVertexAttribPointer
             args = size, gtype, gl.GL_FALSE, stride, offset
-            self._attributes[name] = vbo.handle, handle, func, args
+            self._attributes[name] = vbo.handle, handle, func, args, divisor
 
     def _pre_draw(self):
         self.activate()
@@ -1270,11 +1275,13 @@ class GlirProgram(GlirObject):
             gl.glActiveTexture(gl.GL_TEXTURE0 + unit)
             gl.glBindTexture(tex_target, tex_handle)
         # Activate attributes
-        for vbo_handle, attr_handle, func, args in self._attributes.values():
+        for vbo_handle, attr_handle, func, args, divisor in self._attributes.values():
             if vbo_handle:
                 gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo_handle)
                 gl.glEnableVertexAttribArray(attr_handle)
                 func(attr_handle, *args)
+                if divisor is not None:
+                    gl.glVertexAttribDivisor(attr_handle, divisor)
             else:
                 gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
                 gl.glDisableVertexAttribArray(attr_handle)
@@ -1308,7 +1315,7 @@ class GlirProgram(GlirObject):
         # apps it would not even make sense.
         # self.deactivate()
 
-    def draw(self, mode, selection):
+    def draw(self, mode, selection, instances=1):
         """Draw program in given mode, with given selection (IndexBuffer or
         first, count).
         """
@@ -1334,14 +1341,20 @@ class GlirProgram(GlirObject):
                 self._pre_draw()
                 ibuf = self._parser.get_object(id_)
                 ibuf.activate()
-                gl.glDrawElements(mode, count, as_enum(gtype), None)
+                if instances > 1:
+                    gl.glDrawElementsInstanced(mode, count, as_enum(gtype), None, instances)
+                else:
+                    gl.glDrawElements(mode, count, as_enum(gtype), None)
                 ibuf.deactivate()
         else:
             # Selection based on start and count
             first, count = selection
             if count:
                 self._pre_draw()
-                gl.glDrawArrays(mode, first, count)
+                if instances > 1:
+                    gl.glDrawArraysInstanced(mode, first, count, instances)
+                else:
+                    gl.glDrawArrays(mode, first, count)
         # Wrap up
         gl.check_error('Check after draw')
         self._post_draw()