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

vispy/gloo/program.py

@@ -38,6 +38,18 @@ from .util import check_enum
 from .context import get_current_canvas
 from .preprocessor import preprocess
 
+# ------------------------------------------------------------ Constants ---
+REGEX_VAR = {}
+for kind in ('uniform', 'attribute', 'varying', 'const', 'in', 'out'):
+    REGEX_VAR[kind] = re.compile(fr"\s*{kind}\s+"  # kind of variable
+                                 r"((highp|mediump|lowp)\s+)?"  # Precision (optional)
+                                 r"(?P<type>\w+)\s+"  # type
+                                 r"(?P<name>\w+)\s*"  # name
+                                 r"(\[(?P<size>\d+)\])?"  # size (optional)
+                                 r"(\s*\=\s*[0-9.]+)?"  # default value (optional)
+                                 r"\s*;",  # end
+                                 flags=re.MULTILINE)
+    
 
 # ------------------------------------------------------------ Shader class ---
 class Shader(GLObject):
@@ -235,21 +247,12 @@ class Program(GLObject):
         code = '\n\n'.join([sh.code for sh in self._shaders])
         code = re.sub(r'(.*)(//.*)', r'\1', code, re.M)
 
-        # Regexp to look for variable names
-        var_regexp = (r"\s*VARIABLE\s+"  # kind of variable
-                      r"((highp|mediump|lowp)\s+)?"  # Precision (optional)
-                      r"(?P<type>\w+)\s+"  # type
-                      r"(?P<name>\w+)\s*"  # name
-                      r"(\[(?P<size>\d+)\])?"  # size (optional)
-                      r"(\s*\=\s*[0-9.]+)?"  # default value (optional)
-                      r"\s*;"  # end
-                      )
-
         # Parse uniforms, attributes and varyings
         self._code_variables = {}
         for kind in ('uniform', 'attribute', 'varying', 'const', 'in', 'out'):
-            regex = re.compile(var_regexp.replace('VARIABLE', kind),
-                               flags=re.MULTILINE)
+
+            # pick regex for the correct kind of var
+            reg = REGEX_VAR[kind]
 
             # treat *in* like attribute, *out* like varying
             if kind == 'in':
@@ -257,7 +260,7 @@ class Program(GLObject):
             elif kind == 'out':
                 kind = 'varying'
 
-            for m in re.finditer(regex, code):
+            for m in re.finditer(reg, code):
                 gtype = m.group('type')
                 size = int(m.group('size')) if m.group('size') else -1
                 this_kind = kind
@@ -417,11 +420,12 @@ class Program(GLObject):
                             raise ValueError('data.shape[-1] must be %s '
                                              'not %s for %s'
                                              % (numel, data._last_dim, name))
+                    divisor = getattr(data, 'divisor', None)
                     self._user_variables[name] = data
                     value = (data.id, data.stride, data.offset)
                     self.glir.associate(data.glir)
                     self._glir.command('ATTRIBUTE', self._id,
-                                       name, type_, value)
+                                       name, type_, value, divisor)
                 else:
                     # Single-value attribute; convert to array and check size
                     dtype, numel = self._gtypes[type_]
@@ -431,11 +435,12 @@ class Program(GLObject):
                     if data.size != numel:
                         raise ValueError('Attribute %r needs %i elements, '
                                          'not %i.' % (name, numel, data.size))
+                    divisor = getattr(data, 'divisor', None)
                     # Store and send GLIR command
                     self._user_variables[name] = data
                     value = tuple([0] + [i for i in data])
                     self._glir.command('ATTRIBUTE', self._id,
-                                       name, type_, value)
+                                       name, type_, value, divisor)
             else:
                 raise KeyError('Cannot set data for a %s.' % kind)
         else:
@@ -490,13 +495,25 @@ class Program(GLObject):
         # Check attribute sizes
         attributes = [vbo for vbo in self._user_variables.values()
                       if isinstance(vbo, DataBuffer)]
-        sizes = [a.size for a in attributes]
-        if len(attributes) < 1:
+
+        attrs = [a for a in attributes if getattr(a, 'divisor', None) is None]
+        if len(attrs) < 1:
             raise RuntimeError('Must have at least one attribute')
+        sizes = [a.size for a in attrs]
         if not all(s == sizes[0] for s in sizes[1:]):
-            msg = '\n'.join(['%s: %s' % (str(a), a.size) for a in attributes])
-            raise RuntimeError('All attributes must have the same size, got:\n'
-                               '%s' % msg)
+            msg = '\n'.join([f'{str(a)}: {a.size}' for a in attrs])
+            raise RuntimeError(f'All attributes must have the same size, got:\n{msg}')
+
+        attrs_with_div = [a for a in attributes if a not in attrs]
+        if attrs_with_div:
+            sizes = [a.size for a in attrs_with_div]
+            divs = [a.divisor for a in attrs_with_div]
+            instances = sizes[0] * divs[0]
+            if not all(s * d == instances for s, d in zip(sizes, divs)):
+                msg = '\n'.join([f'{str(a)}: {a.size} * {a.divisor} = {a.size * a.divisor}' for a in attrs_with_div])
+                raise RuntimeError(f'All attributes with divisors must have the same size as the number of instances, got:\n{msg}')
+        else:
+            instances = 1
 
         # Get the glir queue that we need now
         canvas = get_current_canvas()
@@ -513,11 +530,11 @@ class Program(GLObject):
                        np.dtype(np.uint16): 'UNSIGNED_SHORT',
                        np.dtype(np.uint32): 'UNSIGNED_INT'}
             selection = indices.id, gltypes[indices.dtype], indices.size
-            canvas.context.glir.command('DRAW', self._id, mode, selection)
+            canvas.context.glir.command('DRAW', self._id, mode, selection, instances)
         elif indices is None:
             selection = 0, attributes[0].size
             logger.debug("Program drawing %r with %r" % (mode, selection))
-            canvas.context.glir.command('DRAW', self._id, mode, selection)
+            canvas.context.glir.command('DRAW', self._id, mode, selection, instances)
         else:
             raise TypeError("Invalid index: %r (must be IndexBuffer)" %
                             indices)

vispy/gloo/tests/test_program.py

@@ -254,6 +254,13 @@ class ProgramTest(unittest.TestCase):
         # And anything else also fails
         self.assertRaises(KeyError, program.__getitem__, 'fooo')
 
+    def test_type_aliases(self):
+        program = Program("in bool A; out float B;", "foo")
+
+        # in aliased to attribute, out to varying
+        assert ('attribute', 'bool', 'A') in program.variables
+        assert ('varying', 'float', 'B') in program.variables
+
     def test_draw(self):
         # Init
         program = Program("attribute float A;", "uniform float foo")
@@ -267,14 +274,14 @@ class ProgramTest(unittest.TestCase):
             program.draw('triangles')
             glir_cmd = glir.clear()[-1]
             assert glir_cmd[0] == 'DRAW'
-            assert len(glir_cmd[-1]) == 2
+            assert len(glir_cmd[-2]) == 2
 
             # Draw elements
             indices = gloo.IndexBuffer(np.zeros(10, dtype=np.uint8))
             program.draw('triangles', indices)
             glir_cmd = glir.clear()[-1]
             assert glir_cmd[0] == 'DRAW'
-            assert len(glir_cmd[-1]) == 3
+            assert len(glir_cmd[-2]) == 3
 
             # Invalid mode
             self.assertRaises(ValueError, program.draw, 'nogeometricshape')

vispy/gloo/tests/test_texture.py

@@ -5,6 +5,7 @@
 # -----------------------------------------------------------------------------
 import unittest
 import numpy as np
+import pytest
 
 from vispy.gloo import Texture1D, Texture2D, Texture3D, TextureAtlas
 from vispy.testing import requires_pyopengl, run_tests_if_main, assert_raises
@@ -642,7 +643,8 @@ def _test_texture_opengl_formats(Texture, baseshape):
             (1, 'red'),
             (2, 'rg'),
             (3, 'rgb'),
-            (4, 'rgba')
+            (4, 'rgba'),
+            (1, 'depth_component'),
         ]
     )
 
@@ -674,7 +676,8 @@ def _test_texture_internalformats(Texture, baseshape):
         (1, 'red', ['red', 'r8', 'r16', 'r16f', 'r32f']),
         (2, 'rg', ['rg', 'rg8', 'rg16', 'rg16f', 'rg32f']),
         (3, 'rgb', ['rgb', 'rgb8', 'rgb16', 'rgb16f', 'rgb32f']),
-        (4, 'rgba', ['rgba', 'rgba8', 'rgba16', 'rgba16f', 'rgba32f'])
+        (4, 'rgba', ['rgba', 'rgba8', 'rgba16', 'rgba16f', 'rgba32f']),
+        (1, 'depth_component', ['depth_component']),
     ]
 
     for channels in range(1, 5):
@@ -712,4 +715,18 @@ def test_texture_3D_internalformats():
     _test_texture_internalformats(Texture3D, (10, 10, 10))
 
 
+@requires_pyopengl()
+@pytest.mark.parametrize('input_dtype', [np.uint8, np.uint16, np.float32, np.float64])
+@pytest.mark.parametrize('output_dtype', [np.uint8, np.uint16, np.float32, np.float64])
+@pytest.mark.parametrize('ndim', [2, 3])
+def test_texture_set_data_different_dtype(input_dtype, output_dtype, ndim):
+    shape = (20,) * ndim
+    data = np.random.rand(*shape).astype(input_dtype)
+    Texture = Texture2D if ndim == 2 else Texture3D
+
+    tex = Texture(data)
+    tex[:10] = np.array(1, dtype=output_dtype)
+    tex.set_data(data.astype(output_dtype))
+
+
 run_tests_if_main()

vispy/gloo/texture.py

@@ -13,21 +13,49 @@ from .globject import GLObject
 from .util import check_enum
 
 
-F64_PRECISION_WARNING = ("GPUs can't support floating point data with more "
-                         "than 32-bits, precision will be lost due to "
-                         "downcasting to 32-bit float.")
+def get_dtype_limits(dtype):
+    if np.issubdtype(dtype, np.floating):
+        info = np.finfo(dtype)
+    else:
+        info = np.iinfo(dtype)
+    return info.min, info.max
 
 
-def should_cast_to_f32(data_dtype):
-    """Check if data type is floating point with more than 32-bits."""
-    data_dtype = np.dtype(data_dtype)
-    is_floating = np.issubdtype(data_dtype, np.floating)
-    gt_float32 = data_dtype.itemsize > 4
-    if is_floating and gt_float32:
-        # OpenGL can't support floating point numbers greater than 32-bits
-        warnings.warn(F64_PRECISION_WARNING)
-        return True
-    return False
+def convert_dtype_and_clip(data, dtype, copy=False):
+    """
+    cast dtype to a new one, but first clip data to the new dtype's limits if needed
+    """
+    old_min, old_max = get_dtype_limits(data.dtype)
+    new_min, new_max = get_dtype_limits(dtype)
+    if new_max >= old_max and new_min <= old_min:
+        # no need to clip
+        return np.array(data, dtype=dtype, copy=copy)
+    else:
+        # to reduce copying, we clip into a pre-generated array of the right dtype
+        new_data = np.empty_like(data, dtype=dtype)
+        # allow "unsafe" casting here as we're explicitly clipping to the
+        # range of the new dtype - this was a default before numpy 1.25
+        np.clip(data, new_min, new_max, out=new_data, casting="unsafe")
+        return new_data
+
+
+def downcast_to_32bit_if_needed(data, copy=False, dtype=None):
+    """Downcast to 32bit dtype if necessary."""
+    if dtype is None:
+        dtype = data.dtype
+    dtype = np.dtype(dtype)
+    if dtype.itemsize > 4:
+        warnings.warn(
+            f"GPUs can't support dtypes bigger than 32-bit, but got '{dtype}'. "
+            "Precision will be lost due to downcasting to 32-bit.",
+            stacklevel=2,
+        )
+
+    size = min(dtype.itemsize, 4)
+    kind = dtype.kind
+
+    new_dtype = np.dtype(f'{kind}{size}')
+    return convert_dtype_and_clip(data, new_dtype, copy=copy)
 
 
 class BaseTexture(GLObject):
@@ -78,7 +106,8 @@ class BaseTexture(GLObject):
         'luminance_alpha': 2,
         'rg': 2,
         'rgb': 3,
-        'rgba': 4
+        'rgba': 4,
+        'depth_component': 1,
     }
 
     # NOTE: non-normalized formats ending with 'i' and 'ui' are currently
@@ -96,7 +125,8 @@ class BaseTexture(GLObject):
         ('luminance_alpha', 2),
         ('rg', 2),
         ('rgb', 3),
-        ('rgba', 4)
+        ('rgba', 4),
+        ('depth_component', 1),
     ])
 
     def __init__(self, data=None, format=None, resizable=True,
@@ -330,7 +360,7 @@ class BaseTexture(GLObject):
     def _set_data(self, data, offset=None, copy=False):
         """Internal method for set_data."""
         # Copy if needed, check/normalize shape
-        data = np.array(data, copy=copy)
+        data = downcast_to_32bit_if_needed(data, copy=copy)
         data = self._normalize_shape(data)
 
         # Maybe resize to purge DATA commands?

vispy/gloo/wrappers.py

@@ -43,12 +43,14 @@ GL_PRESETS = {
         depth_test=True,
         cull_face=False,
         blend=True,
-        blend_func=('src_alpha', 'one_minus_src_alpha', 'zero', 'one')),
+        blend_func=('src_alpha', 'one_minus_src_alpha', 'zero', 'one'),
+        blend_equation='func_add'),
     'additive': dict(
         depth_test=False,
         cull_face=False,
         blend=True,
-        blend_func=('src_alpha', 'one')),
+        blend_func=('src_alpha', 'one'),
+        blend_equation='func_add'),
 }