vispy 0.14.0__cp311-cp311-macosx_11_0_arm64.whl

vispy/gloo/tests/test_framebuffer.py

@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+
+from vispy.testing import run_tests_if_main, assert_raises
+
+from vispy import gloo
+from vispy.gloo import FrameBuffer, RenderBuffer
+
+
+def test_renderbuffer():
+
+    # Set with no args
+    assert_raises(ValueError, RenderBuffer)
+
+    # Set shape only
+    R = RenderBuffer((10, 20))
+    assert R.shape == (10, 20)
+    assert R.format is None
+
+    # Set both shape and format
+    R = RenderBuffer((10, 20), 'color')
+    assert R.shape == (10, 20)
+    assert R.format == 'color'
+    #
+    glir_cmds = R._glir.clear()
+    assert len(glir_cmds) == 2
+    assert glir_cmds[0][0] == 'CREATE'
+    assert glir_cmds[1][0] == 'SIZE'
+
+    # Orther formats
+    assert RenderBuffer((10, 20), 'depth').format == 'depth'
+    assert RenderBuffer((10, 20), 'stencil').format == 'stencil'
+
+    # Test reset size and format
+    R.resize((9, 9), 'depth')
+    assert R.shape == (9, 9)
+    assert R.format == 'depth'
+    R.resize((8, 8), 'stencil')
+    assert R.shape == (8, 8)
+    assert R.format == 'stencil'
+
+    # Wrong formats
+    assert_raises(ValueError, R.resize, (9, 9), 'no_format')
+    assert_raises(ValueError, R.resize, (9, 9), [])
+
+    # Resizable
+    R = RenderBuffer((10, 20), 'color', False)
+    assert_raises(RuntimeError, R.resize, (9, 9), 'color')
+
+    # Attaching sets the format
+    F = FrameBuffer()
+    #
+    R = RenderBuffer((9, 9))
+    F.color_buffer = R
+    assert F.color_buffer is R
+    assert R.format == 'color'
+    #
+    F.depth_buffer = RenderBuffer((9, 9))
+    assert F.depth_buffer.format == 'depth'
+    #
+    F.stencil_buffer = RenderBuffer((9, 9))
+    assert F.stencil_buffer.format == 'stencil'
+
+
+def test_framebuffer():
+
+    # Test init with no args
+    F = FrameBuffer()
+    glir_cmds = F._glir.clear()
+    assert len(glir_cmds) == 1
+    glir_cmds[0][0] == 'CREATE'
+
+    # Activate / deactivate
+    F.activate()
+    glir_cmd = F._glir.clear()[-1]
+    assert glir_cmd[0] == 'FRAMEBUFFER'
+    assert glir_cmd[2] is True
+    #
+    F.deactivate()
+    glir_cmd = F._glir.clear()[-1]
+    assert glir_cmd[0] == 'FRAMEBUFFER'
+    assert glir_cmd[2] is False
+    #
+    with F:
+        pass
+    glir_cmds = F._glir.clear()
+    assert len(glir_cmds) == 2
+    assert glir_cmds[0][0] == 'FRAMEBUFFER'
+    assert glir_cmds[1][0] == 'FRAMEBUFFER'
+    assert glir_cmds[0][2] is True and glir_cmds[1][2] is False
+
+    # Init with args
+    R = RenderBuffer((3, 3))
+    F = FrameBuffer(R)
+    assert F.color_buffer is R
+    #
+    R2 = RenderBuffer((3, 3))
+    F.color_buffer = R2
+    assert F.color_buffer is R2
+
+    # Wrong buffers
+    F = FrameBuffer()
+    assert_raises(TypeError, FrameBuffer.color_buffer.fset, F, 'FOO')
+    assert_raises(TypeError, FrameBuffer.color_buffer.fset, F, [])
+    assert_raises(TypeError, FrameBuffer.depth_buffer.fset, F, 'FOO')
+    assert_raises(TypeError, FrameBuffer.stencil_buffer.fset, F, 'FOO')
+    color_buffer = RenderBuffer((9, 9), 'color')
+    assert_raises(ValueError, FrameBuffer.depth_buffer.fset, F, color_buffer)
+    # But None is allowed!
+    F.color_buffer = None
+
+    # Shape
+    R1 = RenderBuffer((3, 3))
+    R2 = RenderBuffer((3, 3))
+    R3 = RenderBuffer((3, 3))
+    F = FrameBuffer(R1, R2, R3)
+    assert F.shape == R1.shape 
+    assert R1.format == 'color'
+    assert R2.format == 'depth'
+    assert R3.format == 'stencil'
+    # Resize
+    F.resize((10, 10))
+    assert F.shape == (10, 10)
+    assert F.shape == R1.shape 
+    assert F.shape == R2.shape 
+    assert F.shape == R3.shape 
+    assert R1.format == 'color'
+    assert R2.format == 'depth'
+    assert R3.format == 'stencil'
+    # Shape from any buffer
+    F.color_buffer = None
+    assert F.shape == (10, 10)
+    F.depth_buffer = None
+    assert F.shape == (10, 10)
+    F.stencil_buffer = None
+    assert_raises(RuntimeError, FrameBuffer.shape.fget, F)
+
+    # Also with Texture luminance
+    T = gloo.Texture2D((20, 30))
+    R = RenderBuffer(T.shape)
+    assert T.format == 'luminance'
+    F = FrameBuffer(T, R)
+    assert F.shape == T.shape[:2]
+    assert F.shape == R.shape
+    assert T.format == 'luminance'
+    assert R.format == 'depth'
+    # Resize
+    F.resize((10, 10))
+    assert F.shape == (10, 10)
+    assert T.shape == (10, 10, 1)
+    assert F.shape == R.shape 
+    assert T.format == 'luminance'
+    assert R.format == 'depth'
+
+    # Also with Texture RGB
+    T = gloo.Texture2D((20, 30, 3))
+    R = RenderBuffer(T.shape)
+    assert T.format == 'rgb'
+    F = FrameBuffer(T, R)
+    assert F.shape == T.shape[:2]
+    assert F.shape == R.shape
+    assert T.format == 'rgb'
+    assert R.format == 'depth'
+    # Resize
+    F.resize((10, 10))
+    assert F.shape == (10, 10)
+    assert T.shape == (10, 10, 3)
+    assert F.shape == R.shape 
+    assert T.format == 'rgb'
+    assert R.format == 'depth'
+
+    # Also with Texture for depth
+    T1 = gloo.Texture2D((20, 30, 3))
+    T2 = gloo.Texture2D((20, 30, 1))
+    assert T1.format == 'rgb'
+    assert T2.format == 'luminance'
+    F = FrameBuffer(T1, T2)
+    assert F.shape == T1.shape[:2]
+    assert F.shape == T2.shape[:2]
+    assert T1.format == 'rgb'
+    assert T2.format == 'luminance'
+    # Resize
+    F.resize((10, 10))
+    assert F.shape == (10, 10)
+    assert T1.shape == (10, 10, 3)
+    assert T2.shape == (10, 10, 1)
+    assert T1.format == 'rgb'
+    assert T2.format == 'luminance'
+
+    # Wrong shape in resize
+    assert_raises(ValueError, F. resize, (9, 9, 1))
+    assert_raises(ValueError, F. resize, (9,))
+    assert_raises(ValueError, F. resize, 'FOO')
+
+
+run_tests_if_main()

vispy/gloo/tests/test_glir.py

@@ -0,0 +1,307 @@
+# -*- coding: utf-8 -*-
+
+import json
+import tempfile
+from unittest import mock
+
+from vispy import config
+from vispy.app import Canvas
+from vispy.gloo import glir
+from vispy.testing import requires_application, requires_pyopengl, run_tests_if_main
+
+import numpy as np
+
+
+def test_queue():
+    q = glir.GlirQueue()
+    parser = glir.GlirParser()
+
+    # Test adding commands and clear
+    N = 5
+    for i in range(N):
+        q.command('FOO', 'BAR', i)
+    cmds = q.clear()
+    for i in range(N):
+        assert cmds[i] == ('FOO', 'BAR', i)
+
+    # Test filter 1
+    cmds1 = [('DATA', 1), ('SIZE', 1), ('FOO', 1), ('SIZE', 1), ('FOO', 1),
+             ('DATA', 1), ('DATA', 1)]
+    cmds2 = [c[0] for c in q._shared._filter(cmds1, parser)]
+    assert cmds2 == ['FOO', 'SIZE', 'FOO', 'DATA', 'DATA']
+
+    # Test filter 2
+    cmds1 = [('DATA', 1), ('SIZE', 1), ('FOO', 1), ('SIZE', 2), ('SIZE', 2),
+             ('DATA', 2), ('SIZE', 1), ('FOO', 1), ('DATA', 1), ('DATA', 1)]
+    cmds2 = q._shared._filter(cmds1, parser)
+    assert cmds2 == [('FOO', 1), ('SIZE', 2), ('DATA', 2), ('SIZE', 1),
+                     ('FOO', 1), ('DATA', 1), ('DATA', 1)]
+
+    # Define shader
+    shader1 = """
+        precision highp float;uniform mediump vec4 u_foo;uniform vec4 u_bar;
+        """.strip().replace(';', ';\n')
+    # Convert for desktop
+    shader2 = glir.convert_shader('desktop', shader1)
+    assert 'highp' not in shader2
+    assert 'mediump' not in shader2
+    assert 'precision' not in shader2
+
+    # Convert for es2
+    shader3 = glir.convert_shader('es2', shader2)
+    # make sure precision float is still in the shader
+    # it may not be the first (precision int might be there)
+    assert 'precision highp float;' in shader3
+    # precisions must come before code
+    assert shader3.startswith('precision')
+
+    # Define shader with version number
+    shader4 = """
+        #version 100; precision highp float;uniform mediump vec4 u_foo;uniform vec4 u_bar;
+        """.strip().replace(';', ';\n')
+    shader5 = glir.convert_shader('es2', shader4)
+    assert 'precision highp float;' in shader5
+    # make sure that precision is first (version is removed)
+    # precisions must come before code
+    assert shader3.startswith('precision')
+
+
+@requires_application()
+def test_log_parser():
+    """Test GLIR log parsing"""
+    glir_file = tempfile.TemporaryFile(mode='r+')
+
+    config.update(glir_file=glir_file)
+    with Canvas() as c:
+        c.context.set_clear_color('white')
+        c.context.clear()
+
+    glir_file.seek(0)
+    lines = glir_file.read().split(',\n')
+
+    assert lines[0][0] == '['
+    lines[0] = lines[0][1:]
+
+    assert lines[-1][-1] == ']'
+    lines[-1] = lines[-1][:-1]
+
+    i = 0
+
+    # The FBO argument may be anything based on the backend.
+    expected = json.dumps(['CURRENT', 0, 1])
+    assert len(lines[i]) >= len(expected)
+    expected = expected.split('1')
+    assert lines[i].startswith(expected[0])
+    assert lines[i].endswith(expected[1])
+    assert int(lines[i][len(expected[0]):-len(expected[1])]) is not None
+
+    # The 'CURRENT' command may have been called multiple times
+    while lines[i].startswith('["CURRENT",'):
+        i += 1
+        if lines[i] == json.dumps(['FUNC', 'colorMask', False, False, False, True]):
+            # Qt workaround, see #2040
+            i += 4
+
+    assert lines[i] == json.dumps(['FUNC', 'clearColor', 1.0, 1.0, 1.0, 1.0])
+    i += 1
+    assert lines[i] == json.dumps(['FUNC', 'clear', 17664])
+    i += 1
+    assert lines[i] == json.dumps(['FUNC', 'finish'])
+    i += 1
+
+    config.update(glir_file='')
+    glir_file.close()
+
+
+@requires_application()
+def test_capabilities():
+    """Test GLIR capability reporting"""
+    with Canvas() as c:
+        capabilities = c.context.shared.parser.capabilities
+        assert capabilities['max_texture_size'] is not None
+        assert capabilities['gl_version'] != 'unknown'
+
+
+@requires_pyopengl()
+@mock.patch('vispy.gloo.glir._check_pyopengl_3D')
+@mock.patch('vispy.gloo.glir.gl')
+def test_texture1d_alignment(gl, check3d):
+    """Test that textures set unpack alignment properly.
+
+    See https://github.com/vispy/vispy/pull/1758
+
+    """
+    from ..glir import GlirTexture1D
+    check3d.return_value = check3d
+    t = GlirTexture1D(mock.MagicMock(), 3)
+
+    shape = (393, 1)
+    t.set_size(shape, 'luminance', 'luminance')
+    t.set_data((0,), np.zeros(shape, np.float32))
+    # number of elements doesn't matter, only data type
+    gl.glPixelStorei.assert_not_called()
+    gl.glPixelStorei.reset_mock()
+
+    # now with bytes
+    t.set_data((0,), np.zeros(shape, np.uint8))
+    gl.glPixelStorei.assert_has_calls([
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 1),
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 4),
+    ])
+    gl.glPixelStorei.reset_mock()
+
+    # different shape
+    shape = (394, 1)
+    t.set_size(shape, 'luminance', 'luminance')
+    t.set_data((0,), np.zeros(shape, np.float32))
+    # number of elements doesn't matter, only data type
+    gl.glPixelStorei.assert_not_called()
+    gl.glPixelStorei.reset_mock()
+
+    t.set_data((0,), np.zeros(shape, np.uint8))
+    gl.glPixelStorei.assert_has_calls([
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 1),
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 4),
+    ])
+    gl.glPixelStorei.reset_mock()
+
+
+@requires_pyopengl()
+@mock.patch('vispy.gloo.glir._check_pyopengl_3D')
+@mock.patch('vispy.gloo.glir.gl')
+def test_texture2d_alignment(gl, check3d):
+    """Test that textures set unpack alignment properly.
+
+    See https://github.com/vispy/vispy/pull/1758
+
+    """
+    from ..glir import GlirTexture2D
+    check3d.return_value = gl
+    t = GlirTexture2D(mock.MagicMock(), 3)
+
+    shape = (296, 393, 1)
+    t.set_size(shape, 'luminance', 'luminance')
+    t.set_data((0, 0), np.zeros(shape, np.float32))
+    # alignment should have been 4 which is the default
+    gl.glPixelStorei.assert_not_called()
+    gl.glPixelStorei.reset_mock()
+
+    # now with bytes
+    t.set_data((0, 0), np.zeros(shape, np.uint8))
+    gl.glPixelStorei.assert_has_calls([
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 1),
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 4),
+    ])
+    gl.glPixelStorei.reset_mock()
+
+    # different shape
+    shape = (296, 394, 1)
+    t.set_size(shape, 'luminance', 'luminance')
+    t.set_data((0, 0), np.zeros(shape, np.float32))
+    gl.glPixelStorei.assert_has_calls([
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 8),
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 4),
+    ])
+    gl.glPixelStorei.reset_mock()
+
+    t.set_data((0, 0), np.zeros(shape, np.uint8))
+    gl.glPixelStorei.assert_has_calls([
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 2),
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 4),
+    ])
+    gl.glPixelStorei.reset_mock()
+
+
+@requires_pyopengl()
+@mock.patch('vispy.gloo.glir._check_pyopengl_3D')
+@mock.patch('vispy.gloo.glir.gl')
+def test_texture3d_alignment(gl, check3d):
+    """Test that textures set unpack alignment properly.
+
+    See https://github.com/vispy/vispy/pull/1758
+
+    """
+    from ..glir import GlirTexture3D
+    check3d.return_value = gl
+    t = GlirTexture3D(mock.MagicMock(), 3)
+
+    shape = (68, 296, 393, 1)
+    t.set_size(shape, 'luminance', 'luminance')
+    t.set_data((0, 0, 0), np.zeros(shape, np.float32))
+    # alignment should have been 4 which is the default
+    gl.glPixelStorei.assert_not_called()
+    gl.glPixelStorei.reset_mock()
+
+    # now with bytes
+    t.set_data((0, 0, 0), np.zeros(shape, np.uint8))
+    gl.glPixelStorei.assert_has_calls([
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 1),
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 4),
+    ])
+    gl.glPixelStorei.reset_mock()
+
+    # different shape
+    shape = (68, 296, 394, 1)
+    t.set_size(shape, 'luminance', 'luminance')
+    t.set_data((0, 0, 0), np.zeros(shape, np.float32))
+    gl.glPixelStorei.assert_has_calls([
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 8),
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 4),
+    ])
+    gl.glPixelStorei.reset_mock()
+
+    t.set_data((0, 0, 0), np.zeros(shape, np.uint8))
+    gl.glPixelStorei.assert_has_calls([
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 2),
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 4),
+    ])
+    gl.glPixelStorei.reset_mock()
+
+
+@requires_pyopengl()
+@mock.patch('vispy.gloo.glir._check_pyopengl_3D')
+@mock.patch('vispy.gloo.glir.gl')
+def test_texture_cube_alignment(gl, check3d):
+    """Test that textures set unpack alignment properly.
+
+    See https://github.com/vispy/vispy/pull/1758
+
+    """
+    from ..glir import GlirTextureCube
+    check3d.return_value = gl
+    t = GlirTextureCube(mock.MagicMock(), 3)
+
+    shape = (68, 296, 393, 1)
+    t.set_size(shape, 'luminance', 'luminance')
+    t.set_data((0, 0, 0), np.zeros(shape, np.float32))
+    # alignment should have been 4 which is the default
+    gl.glPixelStorei.assert_not_called()
+    gl.glPixelStorei.reset_mock()
+
+    # now with bytes
+    t.set_data((0, 0, 0), np.zeros(shape, np.uint8))
+    gl.glPixelStorei.assert_has_calls([
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 1),
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 4),
+    ])
+    gl.glPixelStorei.reset_mock()
+
+    # different shape
+    shape = (68, 296, 394, 1)
+    t.set_size(shape, 'luminance', 'luminance')
+    t.set_data((0, 0, 0), np.zeros(shape, np.float32))
+    gl.glPixelStorei.assert_has_calls([
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 8),
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 4),
+    ])
+    gl.glPixelStorei.reset_mock()
+
+    t.set_data((0, 0, 0), np.zeros(shape, np.uint8))
+    gl.glPixelStorei.assert_has_calls([
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 2),
+        mock.call(gl.GL_UNPACK_ALIGNMENT, 4),
+    ])
+    gl.glPixelStorei.reset_mock()
+# The rest is basically tested via our examples
+
+run_tests_if_main()

vispy/gloo/tests/test_globject.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+
+from vispy.testing import run_tests_if_main
+from vispy.gloo.globject import GLObject
+
+
+def test_globject():
+    """Test gl object uinique id and GLIR CREATE command"""
+    objects = [GLObject() for i in range(10)]
+    ids = [ob.id for ob in objects]
+
+    # Verify that each id is unique (test should not care how)
+    assert len(set(ids)) == len(objects)
+
+    # Verify that glir commands have been created
+    commands = []
+    for ob in objects:
+        commands.extend(ob._glir.clear())
+    assert len(commands) == len(objects)
+    for cmd in commands:
+        assert cmd[0] == 'CREATE'
+
+    # Delete
+    ob = objects[-1]
+    q = ob._glir  # get it now, because its gone after we delete it
+    ob.delete()
+    cmd = q.clear()[-1]
+    assert cmd[0] == 'DELETE'
+
+
+run_tests_if_main()