vispy 0.15.0__cp313-cp313-macosx_11_0_arm64.whl

vispy/visuals/shaders/multiprogram.py

@@ -0,0 +1,145 @@
+import weakref
+
+from .program import ModularProgram
+
+
+class MultiProgram(object):
+    """A collection of ModularPrograms that emulates the API of a single
+    ModularProgram. 
+
+    A single Visual is often drawn in many different ways--viewed under
+    different transforms, with different clipping boundaries, or with different
+    colors as in picking and anaglyph stereo. Each draw may require a different
+    program. To simplify this process, MultiProgram exposes an API that looks
+    very much like a single ModularProgram, but internally manages many
+    programs.
+    """
+
+    def __init__(self, vcode='', fcode='', gcode=None):
+        self._vcode = vcode
+        self._fcode = fcode
+        self._gcode = gcode
+        self._programs = weakref.WeakValueDictionary()
+        self._set_items = {}
+        self._next_prog_id = 0
+        self._vert = MultiShader(self, 'vert')
+        self._frag = MultiShader(self, 'frag')
+        self._geom = None if gcode is None else MultiShader(self, 'geom')
+
+    def add_program(self, name=None):
+        """Create a program and add it to this MultiProgram.
+
+        It is the caller's responsibility to keep a reference to the returned 
+        program.
+
+        The *name* must be unique, but is otherwise arbitrary and used for 
+        debugging purposes.
+        """
+        if name is None:
+            name = 'program' + str(self._next_prog_id)
+            self._next_prog_id += 1
+
+        if name in self._programs:
+            raise KeyError("Program named '%s' already exists." % name)
+
+        # create a program and update it to look like the rest
+        prog = ModularProgram(self._vcode, self._fcode, self._gcode)
+        for key, val in self._set_items.items():
+            prog[key] = val
+        self.frag._new_program(prog)
+        self.vert._new_program(prog)
+        if self._geom is not None:
+            self.geom._new_program(prog)
+
+        self._programs[name] = prog
+        return prog
+
+    @property
+    def vert(self):
+        """A wrapper around all vertex shaders contained in this MultiProgram."""
+        return self._vert
+
+    @vert.setter
+    def vert(self, code):
+        self._vcode = code
+        for p in self._programs.values():
+            p.vert = code
+
+    @property
+    def frag(self):
+        """A wrapper around all fragment shaders contained in this MultiProgram."""
+        return self._frag
+
+    @frag.setter
+    def frag(self, code):
+        self._fcode = code
+        for p in self._programs.values():
+            p.frag = code
+
+    @property
+    def geom(self):
+        """A wrapper around all geometry shaders contained in this MultiProgram."""
+        return self._geom
+
+    @geom.setter
+    def geom(self, code):
+        self._gcode = code
+        if self._geom is None:
+            self._geom = MultiShader(self, 'geom')
+        for p in self._programs.values():
+            p.geom = code
+
+    def __contains__(self, key):
+        return any(key in p for p in self._programs.values())
+
+    def __getitem__(self, key):
+        return self._set_items[key]
+
+    def __setitem__(self, key, value):
+        self._set_items[key] = value
+        for program in self._programs.values():
+            program[key] = value
+
+    def __iter__(self):
+        for p in self._programs.values():
+            yield p
+
+    def bind(self, data):
+        for name in data.dtype.names:
+            self[name] = data[name]
+
+
+class MultiShader(object):
+    """Emulates the API of a MainFunction while wrapping all vertex or fragment
+    shaders in a MultiProgram.
+
+    Example::
+
+        mp = MultiProgram(vert, frag)
+        mp.add_program('p1')
+        mp.add_program('p2')
+
+        # applies to all programs
+        mp.vert['u_scale'] = (1, 2)
+
+        # applies to one program
+        mp.get_program('p1').frag['u_color'] = (1, 1, 1, 1)  
+    """
+
+    def __init__(self, program, shader):
+        self._program = program
+        self._shader = shader
+        self._set_items = {}
+
+    def __getitem__(self, key):
+        return self._set_items[key]
+
+    def __setitem__(self, key, value):
+        self._set_items[key] = value
+        for p in self._program._programs.values():
+            getattr(p, self._shader)[key] = value
+
+    def _new_program(self, p):
+        """New program was added to the multiprogram; update items in the shader."""
+        for k, v in self._set_items.items():
+            getattr(p, self._shader)[k] = v

vispy/visuals/shaders/parsing.py

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from __future__ import division
+
+import re
+
+# regular expressions for parsing GLSL
+
+re_version_pragma = r'#version\s+(\d+)(.*)?(//.*)?'
+
+re_type = r'(?:void|int|float|vec2|vec3|vec4|mat2|mat3|mat4|\
+            sampler1D|sampler2D|sampler3D)'
+re_identifier = r'(?:[a-zA-Z_][\w_]*)'
+
+# variable qualifiers
+re_qualifier = r'(const|uniform|attribute|varying|in|out|inout)'
+
+# template variables like
+#     $func_name
+re_template_var = (r"(?:(?:\$" + re_identifier + r")|(?:\$\{" +
+                   re_identifier + r"\}))")
+
+# function names may be either identifier or template var
+re_func_name = r"(" + re_identifier + "|" + re_template_var + ")"
+
+# type and identifier like "vec4 var_name"
+re_declaration = "(?:(" + re_type + r")\s+(" + re_identifier + "))"
+
+# qualifier, type, and identifier like "uniform vec4 var_name"
+# qualifier is optional.
+# may include multiple names like "attribute float x, y, z"
+re_prog_var_declaration = ("(?:" + re_qualifier + r"?\s*(" + re_type +
+                           r")\s+(" + re_identifier + r"(\s*,\s*(" +
+                           re_identifier + "))*))")
+
+# list of variable declarations like "vec4 var_name, float other_var_name"
+re_arg_list = "(" + re_declaration + r"(?:,\s*" + re_declaration + ")*)?"
+
+# function declaration like "vec4 function_name(float x, float y)"
+re_func_decl = ("(" + re_type + r")\s+" + re_func_name + r"\s*\((void|" +
+                re_arg_list + r")\)")
+
+# anonymous variable declarations may or may not include a name:
+#  "vec4" or "vec4 var_name"
+re_anon_decl = "(?:(" + re_type + r")(?:\s+" + re_identifier + ")?)"
+
+# list of anonymous declarations
+re_anon_arg_list = "(" + re_anon_decl + r"(?:,\s*" + re_anon_decl + ")*)?"
+
+# function prototype declaration like
+#    "vec4 function_name(float, float);"
+re_func_prot = ("(" + re_type + r")\s+" + re_func_name + r"\((void|" +
+                re_anon_arg_list + r")\)\s*;")
+
+
+def parse_function_signature(code):
+    """
+    Return the name, arguments, and return type of the first function
+    definition found in *code*. Arguments are returned as [(type, name), ...].
+    """
+    m = re.search(r"^\s*" + re_func_decl + r"\s*{", code, re.M)
+    if m is None:
+        print(code)
+        raise Exception("Failed to parse function signature. "
+                        "Full code is printed above.")
+    rtype, name, args = m.groups()[:3]
+    if args == 'void' or args.strip() == '':
+        args = []
+    else:
+        args = [tuple(arg.strip().split(' ')) for arg in args.split(',')]
+    return name, args, rtype
+
+
+def find_functions(code):
+    """
+    Return a list of (name, arguments, return type) for all function
+    definition2 found in *code*. Arguments are returned as [(type, name), ...].
+    """
+    regex = r"^\s*" + re_func_decl + r"\s*{"
+
+    funcs = []
+    while True:
+        m = re.search(regex, code, re.M)
+        if m is None:
+            return funcs
+
+        rtype, name, args = m.groups()[:3]
+        if args == 'void' or args.strip() == '':
+            args = []
+        else:
+            args = [tuple(arg.strip().split(' ')) for arg in args.split(',')]
+        funcs.append((name, args, rtype))
+
+        code = code[m.end():]
+
+
+def find_prototypes(code):
+    """
+    Return a list of signatures for each function prototype declared in *code*.
+    Format is [(name, [args], rtype), ...].
+    """
+    prots = []
+    lines = code.split('\n')
+    for line in lines:
+        m = re.match(r"\s*" + re_func_prot, line)
+        if m is not None:
+            rtype, name, args = m.groups()[:3]
+            if args == 'void' or args.strip() == '':
+                args = []
+            else:
+                args = [tuple(arg.strip().split(' '))
+                        for arg in args.split(',')]
+            prots.append((name, args, rtype))
+
+    return prots
+
+
+def find_program_variables(code):
+    """
+    Return a dict describing program variables::
+
+        {'var_name': ('uniform|attribute|varying', type), ...}
+
+    """
+    vars = {}
+    lines = code.split('\n')
+    for line in lines:
+        m = re.match(r"\s*" + re_prog_var_declaration + r"\s*(=|;)", line)
+        if m is not None:
+            vtype, dtype, names = m.groups()[:3]
+            for name in names.split(','):
+                vars[name.strip()] = (vtype, dtype)
+    return vars
+
+
+def find_template_variables(code):
+    """Return a list of template variables found in *code*."""
+    return re.findall(re_template_var, code)

vispy/visuals/shaders/program.py

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from __future__ import division
+
+import logging
+from weakref import WeakKeyDictionary
+
+from ...gloo import Program
+from ...gloo.preprocessor import preprocess
+from ...util import logger
+from ...util.event import EventEmitter
+from .function import MainFunction
+from .variable import Variable
+from .compiler import Compiler
+
+
+class ModularProgram(Program):
+    """
+    Shader program using Function instances as basis for its shaders.
+
+    Automatically rebuilds program when functions have changed and uploads
+    program variables.
+    """
+
+    def __init__(self, vcode='', fcode='', gcode=None):
+        Program.__init__(self)
+
+        self.changed = EventEmitter(source=self, type='program_change')
+
+        # Cache state of Variables so we know which ones require update
+        self._variable_cache = WeakKeyDictionary()
+
+        # List of settable variables to be checked for value changes
+        self._variables = []
+
+        self._vert = MainFunction('vertex', '')
+        self._frag = MainFunction('fragment', '')
+        self._vert._dependents[self] = None
+        self._frag._dependents[self] = None
+        self._geom = None
+
+        self.vert = vcode
+        self.frag = fcode
+        self.geom = gcode
+
+    @property
+    def vert(self):
+        return self._vert
+
+    @vert.setter
+    def vert(self, vcode):
+        vcode = preprocess(vcode)
+        self._vert.code = vcode
+        self._need_build = True
+        self.changed(code_changed=True, value_changed=False)
+
+    @property
+    def frag(self):
+        return self._frag
+
+    @frag.setter
+    def frag(self, fcode):
+        fcode = preprocess(fcode)
+        self._frag.code = fcode
+        self._need_build = True
+        self.changed(code_changed=True, value_changed=False)
+
+    @property
+    def geom(self):
+        return self._geom
+
+    @geom.setter
+    def geom(self, gcode):
+        if gcode is None:
+            self._geom = None
+            return
+        gcode = preprocess(gcode)
+        if self._geom is None:
+            self._geom = MainFunction('geometry', '')
+            self._geom._dependents[self] = None
+        self._geom.code = gcode
+        self._need_build = True
+        self.changed(code_changed=True, value_changed=False)
+
+    def _dep_changed(self, dep, code_changed=False, value_changed=False):
+        if code_changed and logger.level <= logging.DEBUG:
+            logger.debug("ModularProgram changed: %s   source=%s, values=%s", 
+                         self, code_changed, value_changed)
+            import traceback
+            traceback.print_stack()
+
+        if code_changed:
+            self._need_build = True
+        self.changed(code_changed=code_changed, 
+                     value_changed=value_changed)
+
+    def draw(self, *args, **kwargs):
+        self.build_if_needed()
+        self.update_variables()
+        Program.draw(self, *args, **kwargs)
+
+    def build_if_needed(self):
+        """Reset shader source if necesssary."""
+        if self._need_build:
+            self._build()
+
+            # after recompile, we need to upload all variables again
+            # (some variables may have changed name)
+            self._variable_cache.clear()
+
+            # Collect a list of all settable variables
+            settable_vars = 'attribute', 'uniform', 'in'
+            deps = [d for d in self.vert.dependencies() if (
+                isinstance(d, Variable) and d.vtype in settable_vars)]
+            deps += [d for d in self.frag.dependencies() if (
+                isinstance(d, Variable) and d.vtype == 'uniform')]
+            if self.geom is not None:
+                deps += [d for d in self.geom.dependencies() if (
+                    isinstance(d, Variable) and d.vtype == 'uniform')]
+            self._variables = deps
+
+            self._need_build = False
+
+    def _build(self):
+        logger.debug("Rebuild ModularProgram: %s", self)
+        shaders = {'vert': self.vert, 'frag': self.frag}
+        if self.geom is not None:
+            shaders['geom'] = self.geom
+        self.compiler = Compiler(**shaders)
+        code = self.compiler.compile()
+
+        # Update shader code, but don't let the program update variables yet 
+        code['update_variables'] = False
+        self.set_shaders(**code)
+
+        logger.debug('==== Vertex Shader ====\n\n%s\n', code['vert'])
+        if 'geom' in code:
+            logger.debug('==== Geometry shader ====\n\n%s\n', code['geom'])
+        logger.debug('==== Fragment shader ====\n\n%s\n', code['frag'])
+
+    def update_variables(self):
+        # Set any variables that have a new value
+        logger.debug("Apply variables:")
+        for dep in sorted(self._variables, key=lambda d: self.compiler[d]):
+            name = self.compiler[dep]
+            state_id = dep.state_id
+            if self._variable_cache.get(dep, None) != state_id:
+                self[name] = dep.value
+                self._variable_cache[dep] = state_id
+                logger.debug("    %s = %s **", name, dep.value)
+            else:
+                logger.debug("    %s = %s", name, dep.value)
+
+        # Process any pending variables and discard anything else that is
+        # not active in the program (otherwise we get lots of warnings).
+        self._process_pending_variables()
+        logger.debug("Discarding unused variables before draw: %s" % 
+                     self._pending_variables.keys())
+        self._pending_variables = {}

vispy/visuals/shaders/shader_object.py

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+from collections import OrderedDict
+from weakref import WeakKeyDictionary
+
+from .compiler import Compiler
+
+
+class ShaderObject(object):
+    """Base class for all objects that may be included in a GLSL program
+    (Functions, Variables, Expressions).
+
+    Shader objects have a *definition* that defines the object in GLSL, an
+    *expression* that is used to reference the object, and a set of
+    *dependencies* that must be declared before the object is used.
+
+    Dependencies are tracked hierarchically such that changes to any object
+    will be propagated up the dependency hierarchy to trigger a recompile.
+    """
+
+    @classmethod
+    def create(self, obj, ref=None):
+        """Convert *obj* to a new ShaderObject. If the output is a Variable
+        with no name, then set its name using *ref*.
+        """
+        if isinstance(ref, Variable):
+            ref = ref.name
+        elif isinstance(ref, str) and ref.startswith('gl_'):
+            # gl_ names not allowed for variables
+            ref = ref[3:].lower()
+
+        # Allow any type of object to be converted to ShaderObject if it
+        # provides a magic method:
+        if hasattr(obj, '_shader_object'):
+            obj = obj._shader_object()
+
+        if isinstance(obj, ShaderObject):
+            if isinstance(obj, Variable) and obj.name is None:
+                obj.name = ref
+        elif isinstance(obj, str):
+            obj = TextExpression(obj)
+        else:
+            obj = Variable(ref, obj)
+            # Try prepending the name to indicate attribute, uniform, varying
+            if obj.vtype and obj.vtype[0] in 'auv':
+                obj.name = obj.vtype[0] + '_' + obj.name
+
+        return obj
+
+    def __init__(self):
+        # objects that must be declared before this object's definition.
+        # {obj: refcount}
+        self._deps = OrderedDict()  # OrderedDict for consistent code output
+
+        # Objects that depend on this one will be informed of changes.
+        self._dependents = WeakKeyDictionary()
+
+    @property
+    def name(self):
+        """The name of this shader object."""
+        return None
+
+    @property
+    def version_pragma(self):
+        """Return version number and extra qualifiers from pragma if present."""
+        return None
+
+    def definition(self, obj_names, version, shader):
+        """Return the GLSL definition for this object. Use *obj_names* to
+        determine the names of dependencies, and *version* (number, qualifier)
+        to adjust code output.
+        """
+        return None
+
+    def expression(self, obj_names):
+        """Return the GLSL expression used to reference this object inline."""
+        return obj_names[self]
+
+    def dependencies(self, sort=False):
+        """Return all dependencies required to use this object. The last item
+        in the list is *self*.
+        """
+        alldeps = []
+        if sort:
+            def key(obj):
+                # sort deps such that we get functions, variables, self.
+                if not isinstance(obj, Variable):
+                    return (0, 0)
+                else:
+                    return (1, obj.vtype)
+
+            deps = sorted(self._deps, key=key)
+        else:
+            deps = self._deps
+
+        for dep in deps:
+            alldeps.extend(dep.dependencies(sort=sort))
+        alldeps.append(self)
+        return alldeps
+
+    def static_names(self):
+        """Return a list of names that are declared in this object's
+        definition (not including the name of the object itself).
+
+        These names will be reserved by the compiler when automatically
+        determining object names.
+        """
+        return []
+
+    def _add_dep(self, dep):
+        """Increment the reference count for *dep*. If this is a new
+        dependency, then connect to its *changed* event.
+        """
+        if dep in self._deps:
+            self._deps[dep] += 1
+        else:
+            self._deps[dep] = 1
+            dep._dependents[self] = None
+
+    def _remove_dep(self, dep):
+        """Decrement the reference count for *dep*. If the reference count
+        reaches 0, then the dependency is removed and its *changed* event is
+        disconnected.
+        """
+        refcount = self._deps[dep]
+        if refcount == 1:
+            self._deps.pop(dep)
+            dep._dependents.pop(self)
+        else:
+            self._deps[dep] -= 1
+
+    def _dep_changed(self, dep, code_changed=False, value_changed=False):
+        """Called when a dependency's expression has changed."""
+        self.changed(code_changed, value_changed)
+
+    def changed(self, code_changed=False, value_changed=False):
+        """Inform dependents that this shaderobject has changed."""
+        for d in self._dependents:
+            d._dep_changed(self, code_changed=code_changed,
+                           value_changed=value_changed)
+
+    def compile(self):
+        """Return a compilation of this object and its dependencies.
+
+        Note: this is mainly for debugging purposes; the names in this code
+        are not guaranteed to match names in any other compilations. Use
+        Compiler directly to ensure consistent naming across multiple objects.
+        """
+        compiler = Compiler(obj=self)
+        return compiler.compile()['obj']
+
+    def __repr__(self):
+        if self.name is not None:
+            return '<%s "%s" at 0x%x>' % (self.__class__.__name__,
+                                          self.name, id(self))
+        else:
+            return '<%s at 0x%x>' % (self.__class__.__name__, id(self))
+
+
+from .variable import Variable  # noqa
+from .expression import TextExpression  # noqa