pyrender-maintained 1.0.0__py3-none-any.whl

pyrender/shader_program.py

@@ -0,0 +1,283 @@
+"""OpenGL shader program wrapper.
+"""
+import numpy as np
+import os
+import re
+
+import OpenGL
+from OpenGL.GL import *
+from OpenGL.GL import shaders as gl_shader_utils
+
+
+class ShaderProgramCache(object):
+    """A cache for shader programs.
+    """
+
+    def __init__(self, shader_dir=None):
+        self._program_cache = {}
+        self.shader_dir = shader_dir
+        if self.shader_dir is None:
+            base_dir, _ = os.path.split(os.path.realpath(__file__))
+            self.shader_dir = os.path.join(base_dir, 'shaders')
+
+    def get_program(self, vertex_shader, fragment_shader,
+                    geometry_shader=None, defines=None):
+        """Get a program via a list of shader files to include in the program.
+
+        Parameters
+        ----------
+        vertex_shader : str
+            The vertex shader filename.
+        fragment_shader : str
+            The fragment shader filename.
+        geometry_shader : str
+            The geometry shader filename.
+        defines : dict
+            Defines and their values for the shader.
+
+        Returns
+        -------
+        program : :class:`.ShaderProgram`
+            The program.
+        """
+        shader_names = []
+        if defines is None:
+            defines = {}
+        shader_filenames = [
+            x for x in [vertex_shader, fragment_shader, geometry_shader]
+            if x is not None
+        ]
+        for fn in shader_filenames:
+            if fn is None:
+                continue
+            _, name = os.path.split(fn)
+            shader_names.append(name)
+        cid = OpenGL.contextdata.getContext()
+        key = tuple([cid] + sorted(
+            [(s,1) for s in shader_names] + [(d, defines[d]) for d in defines]
+        ))
+
+        if key not in self._program_cache:
+            shader_filenames = [
+                os.path.join(self.shader_dir, fn) for fn in shader_filenames
+            ]
+            if len(shader_filenames) == 2:
+                shader_filenames.append(None)
+            vs, fs, gs = shader_filenames
+            self._program_cache[key] = ShaderProgram(
+                vertex_shader=vs, fragment_shader=fs,
+                geometry_shader=gs, defines=defines
+            )
+        return self._program_cache[key]
+
+    def clear(self):
+        for key in self._program_cache:
+            self._program_cache[key].delete()
+        self._program_cache = {}
+
+
+class ShaderProgram(object):
+    """A thin wrapper about OpenGL shader programs that supports easy creation,
+    binding, and uniform-setting.
+
+    Parameters
+    ----------
+    vertex_shader : str
+        The vertex shader filename.
+    fragment_shader : str
+        The fragment shader filename.
+    geometry_shader : str
+        The geometry shader filename.
+    defines : dict
+        Defines and their values for the shader.
+    """
+
+    def __init__(self, vertex_shader, fragment_shader,
+                 geometry_shader=None, defines=None):
+
+        self.vertex_shader = vertex_shader
+        self.fragment_shader = fragment_shader
+        self.geometry_shader = geometry_shader
+
+        self.defines = defines
+        if self.defines is None:
+            self.defines = {}
+
+        self._program_id = None
+        self._vao_id = None  # PYOPENGL BUG
+
+        # DEBUG
+        # self._unif_map = {}
+
+    def _add_to_context(self):
+        if self._program_id is not None:
+            raise ValueError('Shader program already in context')
+        shader_ids = []
+
+        # Load vert shader
+        shader_ids.append(gl_shader_utils.compileShader(
+            self._load(self.vertex_shader), GL_VERTEX_SHADER)
+        )
+        # Load frag shader
+        shader_ids.append(gl_shader_utils.compileShader(
+            self._load(self.fragment_shader), GL_FRAGMENT_SHADER)
+        )
+        # Load geometry shader
+        if self.geometry_shader is not None:
+            shader_ids.append(gl_shader_utils.compileShader(
+                self._load(self.geometry_shader), GL_GEOMETRY_SHADER)
+            )
+
+        # Bind empty VAO PYOPENGL BUG
+        if self._vao_id is None:
+            self._vao_id = glGenVertexArrays(1)
+        glBindVertexArray(self._vao_id)
+
+        # Compile program
+        self._program_id = gl_shader_utils.compileProgram(*shader_ids)
+
+        # Unbind empty VAO PYOPENGL BUG
+        glBindVertexArray(0)
+
+    def _in_context(self):
+        return self._program_id is not None
+
+    def _remove_from_context(self):
+        if self._program_id is not None:
+            glDeleteProgram(self._program_id)
+            glDeleteVertexArrays(1, [self._vao_id])
+            self._program_id = None
+            self._vao_id = None
+
+    def _load(self, shader_filename):
+        path, _ = os.path.split(shader_filename)
+
+        with open(shader_filename) as f:
+            text = f.read()
+
+        def ifdef(matchobj):
+            if matchobj.group(1) in self.defines:
+                return '#if 1'
+            else:
+                return '#if 0'
+
+        def ifndef(matchobj):
+            if matchobj.group(1) in self.defines:
+                return '#if 0'
+            else:
+                return '#if 1'
+
+        ifdef_regex = re.compile(
+            '#ifdef\\s+([a-zA-Z_][a-zA-Z_0-9]*)\\s*$', re.MULTILINE
+        )
+        ifndef_regex = re.compile(
+            '#ifndef\\s+([a-zA-Z_][a-zA-Z_0-9]*)\\s*$', re.MULTILINE
+        )
+        text = re.sub(ifdef_regex, ifdef, text)
+        text = re.sub(ifndef_regex, ifndef, text)
+
+        for define in self.defines:
+            value = str(self.defines[define])
+            text = text.replace(define, value)
+
+        return text
+
+    def _bind(self):
+        """Bind this shader program to the current OpenGL context.
+        """
+        if self._program_id is None:
+            raise ValueError('Cannot bind program that is not in context')
+        # glBindVertexArray(self._vao_id)
+        glUseProgram(self._program_id)
+
+    def _unbind(self):
+        """Unbind this shader program from the current OpenGL context.
+        """
+        glUseProgram(0)
+
+    def delete(self):
+        """Delete this shader program from the current OpenGL context.
+        """
+        self._remove_from_context()
+
+    def set_uniform(self, name, value, unsigned=False):
+        """Set a uniform value in the current shader program.
+
+        Parameters
+        ----------
+        name : str
+            Name of the uniform to set.
+        value : int, float, or ndarray
+            Value to set the uniform to.
+        unsigned : bool
+            If True, ints will be treated as unsigned values.
+        """
+        try:
+            # DEBUG
+            # self._unif_map[name] = 1, (1,)
+            loc = glGetUniformLocation(self._program_id, name)
+
+            if loc == -1:
+                raise ValueError('Invalid shader variable: {}'.format(name))
+
+            if isinstance(value, np.ndarray):
+                # DEBUG
+                # self._unif_map[name] = value.size, value.shape
+                if value.ndim == 1:
+                    if (np.issubdtype(value.dtype, np.unsignedinteger) or
+                            unsigned):
+                        dtype = 'u'
+                        value = value.astype(np.uint32)
+                    elif np.issubdtype(value.dtype, np.integer):
+                        dtype = 'i'
+                        value = value.astype(np.int32)
+                    else:
+                        dtype = 'f'
+                        value = value.astype(np.float32)
+                    self._FUNC_MAP[(value.shape[0], dtype)](loc, 1, value)
+                else:
+                    self._FUNC_MAP[(value.shape[0], value.shape[1])](
+                        loc, 1, GL_TRUE, value
+                    )
+
+            # Call correct uniform function
+            elif isinstance(value, float):
+                glUniform1f(loc, value)
+            elif isinstance(value, int):
+                if unsigned:
+                    glUniform1ui(loc, value)
+                else:
+                    glUniform1i(loc, value)
+            elif isinstance(value, bool):
+                if unsigned:
+                    glUniform1ui(loc, int(value))
+                else:
+                    glUniform1i(loc, int(value))
+            else:
+                raise ValueError('Invalid data type')
+        except Exception:
+            pass
+
+    _FUNC_MAP = {
+        (1,'u'): glUniform1uiv,
+        (2,'u'): glUniform2uiv,
+        (3,'u'): glUniform3uiv,
+        (4,'u'): glUniform4uiv,
+        (1,'i'): glUniform1iv,
+        (2,'i'): glUniform2iv,
+        (3,'i'): glUniform3iv,
+        (4,'i'): glUniform4iv,
+        (1,'f'): glUniform1fv,
+        (2,'f'): glUniform2fv,
+        (3,'f'): glUniform3fv,
+        (4,'f'): glUniform4fv,
+        (2,2): glUniformMatrix2fv,
+        (2,3): glUniformMatrix2x3fv,
+        (2,4): glUniformMatrix2x4fv,
+        (3,2): glUniformMatrix3x2fv,
+        (3,3): glUniformMatrix3fv,
+        (3,4): glUniformMatrix3x4fv,
+        (4,2): glUniformMatrix4x2fv,
+        (4,3): glUniformMatrix4x3fv,
+        (4,4): glUniformMatrix4fv,
+    }

pyrender/texture.py

@@ -0,0 +1,259 @@
+"""Textures, conforming to the glTF 2.0 standards as specified in
+https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-texture
+
+Author: Matthew Matl
+"""
+import numpy as np
+
+from OpenGL.GL import *
+
+from .utils import format_texture_source
+from .sampler import Sampler
+
+
+class Texture(object):
+    """A texture and its sampler.
+
+    Parameters
+    ----------
+    name : str, optional
+        The user-defined name of this object.
+    sampler : :class:`Sampler`
+        The sampler used by this texture.
+    source : (h,w,c) uint8 or (h,w,c) float or :class:`PIL.Image.Image`
+        The image used by this texture. If None, the texture is created
+        empty and width and height must be specified.
+    source_channels : str
+        Either `D`, `R`, `RG`, `GB`, `RGB`, or `RGBA`. Indicates the
+        channels to extract from `source`. Any missing channels will be filled
+        with `1.0`.
+    width : int, optional
+        For empty textures, the width of the texture buffer.
+    height : int, optional
+        For empty textures, the height of the texture buffer.
+    tex_type : int
+        Either GL_TEXTURE_2D or GL_TEXTURE_CUBE.
+    data_format : int
+        For now, just GL_FLOAT.
+    """
+
+    def __init__(self,
+                 name=None,
+                 sampler=None,
+                 source=None,
+                 source_channels=None,
+                 width=None,
+                 height=None,
+                 tex_type=GL_TEXTURE_2D,
+                 data_format=GL_UNSIGNED_BYTE):
+        self.source_channels = source_channels
+        self.name = name
+        self.sampler = sampler
+        self.source = source
+        self.width = width
+        self.height = height
+        self.tex_type = tex_type
+        self.data_format = data_format
+
+        self._texid = None
+        self._is_transparent = False
+
+    @property
+    def name(self):
+        """str : The user-defined name of this object.
+        """
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        if value is not None:
+            value = str(value)
+        self._name = value
+
+    @property
+    def sampler(self):
+        """:class:`Sampler` : The sampler used by this texture.
+        """
+        return self._sampler
+
+    @sampler.setter
+    def sampler(self, value):
+        if value is None:
+            value = Sampler()
+        self._sampler = value
+
+    @property
+    def source(self):
+        """(h,w,c) uint8 or float or :class:`PIL.Image.Image` : The image
+        used in this texture.
+        """
+        return self._source
+
+    @source.setter
+    def source(self, value):
+        if value is None:
+            self._source = None
+        else:
+            self._source = format_texture_source(value, self.source_channels)
+        self._is_transparent = False
+
+    @property
+    def source_channels(self):
+        """str : The channels that were extracted from the original source.
+        """
+        return self._source_channels
+
+    @source_channels.setter
+    def source_channels(self, value):
+        self._source_channels = value
+
+    @property
+    def width(self):
+        """int : The width of the texture buffer.
+        """
+        return self._width
+
+    @width.setter
+    def width(self, value):
+        self._width = value
+
+    @property
+    def height(self):
+        """int : The height of the texture buffer.
+        """
+        return self._height
+
+    @height.setter
+    def height(self, value):
+        self._height = value
+
+    @property
+    def tex_type(self):
+        """int : The type of the texture.
+        """
+        return self._tex_type
+
+    @tex_type.setter
+    def tex_type(self, value):
+        self._tex_type = value
+
+    @property
+    def data_format(self):
+        """int : The format of the texture data.
+        """
+        return self._data_format
+
+    @data_format.setter
+    def data_format(self, value):
+        self._data_format = value
+
+    def is_transparent(self, cutoff=1.0):
+        """bool : If True, the texture is partially transparent.
+        """
+        if self._is_transparent is None:
+            self._is_transparent = False
+            if self.source_channels == 'RGBA' and self.source is not None:
+                if np.any(self.source[:,:,3] < cutoff):
+                    self._is_transparent = True
+        return self._is_transparent
+
+    def delete(self):
+        """Remove this texture from the OpenGL context.
+        """
+        self._unbind()
+        self._remove_from_context()
+
+    ##################
+    # OpenGL code
+    ##################
+    def _add_to_context(self):
+        if self._texid is not None:
+            raise ValueError('Texture already loaded into OpenGL context')
+
+        fmt = GL_DEPTH_COMPONENT
+        if self.source_channels == 'R':
+            fmt = GL_RED
+        elif self.source_channels == 'RG' or self.source_channels == 'GB':
+            fmt = GL_RG
+        elif self.source_channels == 'RGB':
+            fmt = GL_RGB
+        elif self.source_channels == 'RGBA':
+            fmt = GL_RGBA
+
+        # Generate the OpenGL texture
+        self._texid = glGenTextures(1)
+        glBindTexture(self.tex_type, self._texid)
+
+        # Flip data for OpenGL buffer
+        data = None
+        width = self.width
+        height = self.height
+        if self.source is not None:
+            data = np.ascontiguousarray(np.flip(self.source, axis=0).flatten())
+            width = self.source.shape[1]
+            height = self.source.shape[0]
+
+        # Bind texture and generate mipmaps
+        glTexImage2D(
+            self.tex_type, 0, fmt, width, height, 0, fmt,
+            self.data_format, data
+        )
+        if self.source is not None:
+            glGenerateMipmap(self.tex_type)
+
+        if self.sampler.magFilter is not None:
+            glTexParameteri(
+                self.tex_type, GL_TEXTURE_MAG_FILTER, self.sampler.magFilter
+            )
+        else:
+            if self.source is not None:
+                glTexParameteri(self.tex_type, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+            else:
+                glTexParameteri(self.tex_type, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+        if self.sampler.minFilter is not None:
+            glTexParameteri(
+                self.tex_type, GL_TEXTURE_MIN_FILTER, self.sampler.minFilter
+            )
+        else:
+            if self.source is not None:
+                glTexParameteri(self.tex_type, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR)
+            else:
+                glTexParameteri(self.tex_type, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+
+        glTexParameteri(self.tex_type, GL_TEXTURE_WRAP_S, self.sampler.wrapS)
+        glTexParameteri(self.tex_type, GL_TEXTURE_WRAP_T, self.sampler.wrapT)
+        border_color = 255 * np.ones(4).astype(np.uint8)
+        if self.data_format == GL_FLOAT:
+            border_color = np.ones(4).astype(np.float32)
+        glTexParameterfv(
+            self.tex_type, GL_TEXTURE_BORDER_COLOR,
+            border_color
+        )
+
+        # Unbind texture
+        glBindTexture(self.tex_type, 0)
+
+    def _remove_from_context(self):
+        if self._texid is not None:
+            # TODO OPENGL BUG?
+            # glDeleteTextures(1, [self._texid])
+            glDeleteTextures([self._texid])
+            self._texid = None
+
+    def _in_context(self):
+        return self._texid is not None
+
+    def _bind(self):
+        # TODO HANDLE INDEXING INTO OTHER UV's
+        glBindTexture(self.tex_type, self._texid)
+
+    def _unbind(self):
+        glBindTexture(self.tex_type, 0)
+
+    def _bind_as_depth_attachment(self):
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                               self.tex_type, self._texid, 0)
+
+    def _bind_as_color_attachment(self):
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                               self.tex_type, self._texid, 0)