pyrender-maintained 1.0.0__py3-none-any.whl

pyrender/font.py

@@ -0,0 +1,272 @@
+"""Font texture loader and processor.
+
+Author: Matthew Matl
+"""
+import freetype
+import numpy as np
+import os
+
+import OpenGL
+from OpenGL.GL import *
+
+from .constants import TextAlign, FLOAT_SZ
+from .texture import Texture
+from .sampler import Sampler
+
+
+class FontCache(object):
+    """A cache for fonts.
+    """
+
+    def __init__(self, font_dir=None):
+        self._font_cache = {}
+        self.font_dir = font_dir
+        if self.font_dir is None:
+            base_dir, _ = os.path.split(os.path.realpath(__file__))
+            self.font_dir = os.path.join(base_dir, 'fonts')
+
+    def get_font(self, font_name, font_pt):
+        # If it's a file, load it directly, else, try to load from font dir.
+        if os.path.isfile(font_name):
+            font_filename = font_name
+            _, font_name = os.path.split(font_name)
+            font_name, _ = os.path.split(font_name)
+        else:
+            font_filename = os.path.join(self.font_dir, font_name) + '.ttf'
+
+        cid = OpenGL.contextdata.getContext()
+        key = (cid, font_name, int(font_pt))
+
+        if key not in self._font_cache:
+            self._font_cache[key] = Font(font_filename, font_pt)
+        return self._font_cache[key]
+
+    def clear(self):
+        for key in self._font_cache:
+            self._font_cache[key].delete()
+        self._font_cache = {}
+
+
+class Character(object):
+    """A single character, with its texture and attributes.
+    """
+
+    def __init__(self, texture, size, bearing, advance):
+        self.texture = texture
+        self.size = size
+        self.bearing = bearing
+        self.advance = advance
+
+
+class Font(object):
+    """A font object.
+
+    Parameters
+    ----------
+    font_file : str
+        The file to load the font from.
+    font_pt : int
+        The height of the font in pixels.
+    """
+
+    def __init__(self, font_file, font_pt=40):
+        self.font_file = font_file
+        self.font_pt = int(font_pt)
+        self._face = freetype.Face(font_file)
+        self._face.set_pixel_sizes(0, font_pt)
+        self._character_map = {}
+
+        for i in range(0, 128):
+
+            # Generate texture
+            face = self._face
+            face.load_char(chr(i))
+            buf = face.glyph.bitmap.buffer
+            src = (np.array(buf) / 255.0).astype(np.float32)
+            src = src.reshape((face.glyph.bitmap.rows,
+                               face.glyph.bitmap.width))
+            tex = Texture(
+                sampler=Sampler(
+                    magFilter=GL_LINEAR,
+                    minFilter=GL_LINEAR,
+                    wrapS=GL_CLAMP_TO_EDGE,
+                    wrapT=GL_CLAMP_TO_EDGE
+                ),
+                source=src,
+                source_channels='R',
+            )
+            character = Character(
+                texture=tex,
+                size=np.array([face.glyph.bitmap.width,
+                               face.glyph.bitmap.rows]),
+                bearing=np.array([face.glyph.bitmap_left,
+                                  face.glyph.bitmap_top]),
+                advance=face.glyph.advance.x
+            )
+            self._character_map[chr(i)] = character
+
+        self._vbo = None
+        self._vao = None
+
+    @property
+    def font_file(self):
+        """str : The file the font was loaded from.
+        """
+        return self._font_file
+
+    @font_file.setter
+    def font_file(self, value):
+        self._font_file = value
+
+    @property
+    def font_pt(self):
+        """int : The height of the font in pixels.
+        """
+        return self._font_pt
+
+    @font_pt.setter
+    def font_pt(self, value):
+        self._font_pt = int(value)
+
+    def _add_to_context(self):
+
+        self._vao = glGenVertexArrays(1)
+        glBindVertexArray(self._vao)
+        self._vbo = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self._vbo)
+        glBufferData(GL_ARRAY_BUFFER, FLOAT_SZ * 6 * 4, None, GL_DYNAMIC_DRAW)
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(
+            0, 4, GL_FLOAT, GL_FALSE, 4 * FLOAT_SZ, ctypes.c_void_p(0)
+        )
+        glBindVertexArray(0)
+
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
+        for c in self._character_map:
+            ch = self._character_map[c]
+            if not ch.texture._in_context():
+                ch.texture._add_to_context()
+
+    def _remove_from_context(self):
+        for c in self._character_map:
+            ch = self._character_map[c]
+            ch.texture.delete()
+        if self._vao is not None:
+            glDeleteVertexArrays(1, [self._vao])
+            glDeleteBuffers(1, [self._vbo])
+            self._vao = None
+            self._vbo = None
+
+    def _in_context(self):
+        return self._vao is not None
+
+    def _bind(self):
+        glBindVertexArray(self._vao)
+
+    def _unbind(self):
+        glBindVertexArray(0)
+
+    def delete(self):
+        self._unbind()
+        self._remove_from_context()
+
+    def render_string(self, text, x, y, scale=1.0,
+                      align=TextAlign.BOTTOM_LEFT):
+        """Render a string to the current view buffer.
+
+        Note
+        ----
+        Assumes correct shader program already bound w/ uniforms set.
+
+        Parameters
+        ----------
+        text : str
+            The text to render.
+        x : int
+            Horizontal pixel location of text.
+        y : int
+            Vertical pixel location of text.
+        scale : int
+            Scaling factor for text.
+        align : int
+            One of the TextAlign options which specifies where the ``x``
+            and ``y`` parameters lie on the text. For example,
+            :attr:`.TextAlign.BOTTOM_LEFT` means that ``x`` and ``y`` indicate
+            the position of the bottom-left corner of the textbox.
+        """
+        glActiveTexture(GL_TEXTURE0)
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        glDisable(GL_DEPTH_TEST)
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+        self._bind()
+
+        # Determine width and height of text relative to x, y
+        width = 0.0
+        height = 0.0
+        for c in text:
+            ch = self._character_map[c]
+            height = max(height, ch.bearing[1] * scale)
+            width += (ch.advance >> 6) * scale
+
+        # Determine offsets based on alignments
+        xoff = 0
+        yoff = 0
+        if align == TextAlign.BOTTOM_RIGHT:
+            xoff = -width
+        elif align == TextAlign.BOTTOM_CENTER:
+            xoff = -width / 2.0
+        elif align == TextAlign.TOP_LEFT:
+            yoff = -height
+        elif align == TextAlign.TOP_RIGHT:
+            yoff = -height
+            xoff = -width
+        elif align == TextAlign.TOP_CENTER:
+            yoff = -height
+            xoff = -width / 2.0
+        elif align == TextAlign.CENTER:
+            xoff = -width / 2.0
+            yoff = -height / 2.0
+        elif align == TextAlign.CENTER_LEFT:
+            yoff = -height / 2.0
+        elif align == TextAlign.CENTER_RIGHT:
+            xoff = -width
+            yoff = -height / 2.0
+
+        x += xoff
+        y += yoff
+
+        ch = None
+        for c in text:
+            ch = self._character_map[c]
+            xpos = x + ch.bearing[0] * scale
+            ypos = y - (ch.size[1] - ch.bearing[1]) * scale
+            w = ch.size[0] * scale
+            h = ch.size[1] * scale
+
+            vertices = np.array([
+                [xpos, ypos, 0.0, 0.0],
+                [xpos + w, ypos, 1.0, 0.0],
+                [xpos + w, ypos + h, 1.0, 1.0],
+                [xpos + w, ypos + h, 1.0, 1.0],
+                [xpos, ypos + h, 0.0, 1.0],
+                [xpos, ypos, 0.0, 0.0],
+            ], dtype=np.float32)
+
+            ch.texture._bind()
+
+            glBindBuffer(GL_ARRAY_BUFFER, self._vbo)
+            glBufferData(
+                GL_ARRAY_BUFFER, FLOAT_SZ * 6 * 4, vertices, GL_DYNAMIC_DRAW
+            )
+            # TODO MAKE THIS MORE EFFICIENT, lgBufferSubData is broken
+            # glBufferSubData(
+            #     GL_ARRAY_BUFFER, 0, 6 * 4 * FLOAT_SZ,
+            #     np.ascontiguousarray(vertices.flatten)
+            # )
+            glDrawArrays(GL_TRIANGLES, 0, 6)
+            x += (ch.advance >> 6) * scale
+
+        self._unbind()
+        if ch:
+            ch.texture._unbind()

pyrender/light.py

@@ -0,0 +1,382 @@
+"""Punctual light sources as defined by the glTF 2.0 KHR extension at
+https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
+
+Author: Matthew Matl
+"""
+import abc
+import numpy as np
+
+from OpenGL.GL import *
+
+from .utils import format_color_vector
+from .texture import Texture
+from .constants import SHADOW_TEX_SZ
+from .camera import OrthographicCamera, PerspectiveCamera
+
+
+class Light(abc.ABC):
+    """Base class for all light objects.
+
+    Parameters
+    ----------
+    color : (3,) float
+        RGB value for the light's color in linear space.
+    intensity : float
+        Brightness of light. The units that this is defined in depend on the
+        type of light. Point and spot lights use luminous intensity in candela
+        (lm/sr), while directional lights use illuminance in lux (lm/m2).
+    name : str, optional
+        Name of the light.
+    """
+    def __init__(self,
+                 color=None,
+                 intensity=None,
+                 name=None):
+
+        if color is None:
+            color = np.ones(3)
+        if intensity is None:
+            intensity = 1.0
+
+        self.name = name
+        self.color = color
+        self.intensity = intensity
+        self._shadow_camera = None
+        self._shadow_texture = None
+
+    @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 color(self):
+        """(3,) float : The light's color.
+        """
+        return self._color
+
+    @color.setter
+    def color(self, value):
+        self._color = format_color_vector(value, 3)
+
+    @property
+    def intensity(self):
+        """float : The light's intensity in candela or lux.
+        """
+        return self._intensity
+
+    @intensity.setter
+    def intensity(self, value):
+        self._intensity = float(value)
+
+    @property
+    def shadow_texture(self):
+        """:class:`.Texture` : A texture used to hold shadow maps for this light.
+        """
+        return self._shadow_texture
+
+    @shadow_texture.setter
+    def shadow_texture(self, value):
+        if self._shadow_texture is not None:
+            if self._shadow_texture._in_context():
+                self._shadow_texture.delete()
+        self._shadow_texture = value
+
+    @abc.abstractmethod
+    def _generate_shadow_texture(self, size=None):
+        """Generate a shadow texture for this light.
+
+        Parameters
+        ----------
+        size : int, optional
+            Size of texture map. Must be a positive power of two.
+        """
+        pass
+
+    @abc.abstractmethod
+    def _get_shadow_camera(self, scene_scale):
+        """Generate and return a shadow mapping camera for this light.
+
+        Parameters
+        ----------
+        scene_scale : float
+            Length of scene's bounding box diagonal.
+
+        Returns
+        -------
+        camera : :class:`.Camera`
+            The camera used to render shadowmaps for this light.
+        """
+        pass
+
+
+class DirectionalLight(Light):
+    """Directional lights are light sources that act as though they are
+    infinitely far away and emit light in the direction of the local -z axis.
+    This light type inherits the orientation of the node that it belongs to;
+    position and scale are ignored except for their effect on the inherited
+    node orientation. Because it is at an infinite distance, the light is
+    not attenuated. Its intensity is defined in lumens per metre squared,
+    or lux (lm/m2).
+
+    Parameters
+    ----------
+    color : (3,) float, optional
+        RGB value for the light's color in linear space. Defaults to white
+        (i.e. [1.0, 1.0, 1.0]).
+    intensity : float, optional
+        Brightness of light, in lux (lm/m^2). Defaults to 1.0
+    name : str, optional
+        Name of the light.
+    """
+
+    def __init__(self,
+                 color=None,
+                 intensity=None,
+                 name=None):
+        super(DirectionalLight, self).__init__(
+            color=color,
+            intensity=intensity,
+            name=name,
+        )
+
+    def _generate_shadow_texture(self, size=None):
+        """Generate a shadow texture for this light.
+
+        Parameters
+        ----------
+        size : int, optional
+            Size of texture map. Must be a positive power of two.
+        """
+        if size is None:
+            size = SHADOW_TEX_SZ
+        self.shadow_texture = Texture(width=size, height=size,
+                                      source_channels='D', data_format=GL_FLOAT)
+
+    def _get_shadow_camera(self, scene_scale):
+        """Generate and return a shadow mapping camera for this light.
+
+        Parameters
+        ----------
+        scene_scale : float
+            Length of scene's bounding box diagonal.
+
+        Returns
+        -------
+        camera : :class:`.Camera`
+            The camera used to render shadowmaps for this light.
+        """
+        return OrthographicCamera(
+            znear=0.01 * scene_scale,
+            zfar=10 * scene_scale,
+            xmag=scene_scale,
+            ymag=scene_scale
+        )
+
+
+class PointLight(Light):
+    """Point lights emit light in all directions from their position in space;
+    rotation and scale are ignored except for their effect on the inherited
+    node position. The brightness of the light attenuates in a physically
+    correct manner as distance increases from the light's position (i.e.
+    brightness goes like the inverse square of the distance). Point light
+    intensity is defined in candela, which is lumens per square radian (lm/sr).
+
+    Parameters
+    ----------
+    color : (3,) float
+        RGB value for the light's color in linear space.
+    intensity : float
+        Brightness of light in candela (lm/sr).
+    range : float
+        Cutoff distance at which light's intensity may be considered to
+        have reached zero. If None, the range is assumed to be infinite.
+    name : str, optional
+        Name of the light.
+    """
+
+    def __init__(self,
+                 color=None,
+                 intensity=None,
+                 range=None,
+                 name=None):
+        super(PointLight, self).__init__(
+            color=color,
+            intensity=intensity,
+            name=name,
+        )
+        self.range = range
+
+    @property
+    def range(self):
+        """float : The cutoff distance for the light.
+        """
+        return self._range
+
+    @range.setter
+    def range(self, value):
+        if value is not None:
+            value = float(value)
+            if value <= 0:
+                raise ValueError('Range must be > 0')
+            self._range = value
+        self._range = value
+
+    def _generate_shadow_texture(self, size=None):
+        """Generate a shadow texture for this light.
+
+        Parameters
+        ----------
+        size : int, optional
+            Size of texture map. Must be a positive power of two.
+        """
+        raise NotImplementedError('Shadows not implemented for point lights')
+
+    def _get_shadow_camera(self, scene_scale):
+        """Generate and return a shadow mapping camera for this light.
+
+        Parameters
+        ----------
+        scene_scale : float
+            Length of scene's bounding box diagonal.
+
+        Returns
+        -------
+        camera : :class:`.Camera`
+            The camera used to render shadowmaps for this light.
+        """
+        raise NotImplementedError('Shadows not implemented for point lights')
+
+
+class SpotLight(Light):
+    """Spot lights emit light in a cone in the direction of the local -z axis.
+    The angle and falloff of the cone is defined using two numbers, the
+    ``innerConeAngle`` and ``outerConeAngle``.
+    As with point lights, the brightness
+    also attenuates in a physically correct manner as distance increases from
+    the light's position (i.e. brightness goes like the inverse square of the
+    distance). Spot light intensity refers to the brightness inside the
+    ``innerConeAngle`` (and at the location of the light) and is defined in
+    candela, which is lumens per square radian (lm/sr). A spot light's position
+    and orientation are inherited from its node transform. Inherited scale does
+    not affect cone shape, and is ignored except for its effect on position
+    and orientation.
+
+    Parameters
+    ----------
+    color : (3,) float
+        RGB value for the light's color in linear space.
+    intensity : float
+        Brightness of light in candela (lm/sr).
+    range : float
+        Cutoff distance at which light's intensity may be considered to
+        have reached zero. If None, the range is assumed to be infinite.
+    innerConeAngle : float
+        Angle, in radians, from centre of spotlight where falloff begins.
+        Must be greater than or equal to ``0`` and less
+        than ``outerConeAngle``. Defaults to ``0``.
+    outerConeAngle : float
+        Angle, in radians, from centre of spotlight where falloff ends.
+        Must be greater than ``innerConeAngle`` and less than or equal to
+        ``PI / 2.0``. Defaults to ``PI / 4.0``.
+    name : str, optional
+        Name of the light.
+    """
+
+    def __init__(self,
+                 color=None,
+                 intensity=None,
+                 range=None,
+                 innerConeAngle=0.0,
+                 outerConeAngle=(np.pi / 4.0),
+                 name=None):
+        super(SpotLight, self).__init__(
+            name=name,
+            color=color,
+            intensity=intensity,
+        )
+        self.outerConeAngle = outerConeAngle
+        self.innerConeAngle = innerConeAngle
+        self.range = range
+
+    @property
+    def innerConeAngle(self):
+        """float : The inner cone angle in radians.
+        """
+        return self._innerConeAngle
+
+    @innerConeAngle.setter
+    def innerConeAngle(self, value):
+        if value < 0.0 or value > self.outerConeAngle:
+            raise ValueError('Invalid value for inner cone angle')
+        self._innerConeAngle = float(value)
+
+    @property
+    def outerConeAngle(self):
+        """float : The outer cone angle in radians.
+        """
+        return self._outerConeAngle
+
+    @outerConeAngle.setter
+    def outerConeAngle(self, value):
+        if value < 0.0 or value > np.pi / 2.0 + 1e-9:
+            raise ValueError('Invalid value for outer cone angle')
+        self._outerConeAngle = float(value)
+
+    @property
+    def range(self):
+        """float : The cutoff distance for the light.
+        """
+        return self._range
+
+    @range.setter
+    def range(self, value):
+        if value is not None:
+            value = float(value)
+            if value <= 0:
+                raise ValueError('Range must be > 0')
+            self._range = value
+        self._range = value
+
+    def _generate_shadow_texture(self, size=None):
+        """Generate a shadow texture for this light.
+
+        Parameters
+        ----------
+        size : int, optional
+            Size of texture map. Must be a positive power of two.
+        """
+        if size is None:
+            size = SHADOW_TEX_SZ
+        self.shadow_texture = Texture(width=size, height=size,
+                                      source_channels='D', data_format=GL_FLOAT)
+
+    def _get_shadow_camera(self, scene_scale):
+        """Generate and return a shadow mapping camera for this light.
+
+        Parameters
+        ----------
+        scene_scale : float
+            Length of scene's bounding box diagonal.
+
+        Returns
+        -------
+        camera : :class:`.Camera`
+            The camera used to render shadowmaps for this light.
+        """
+        return PerspectiveCamera(
+            znear=0.01 * scene_scale,
+            zfar=10 * scene_scale,
+            yfov=np.clip(2 * self.outerConeAngle + np.pi / 16.0, 0.0, np.pi),
+            aspectRatio=1.0
+        )
+
+
+__all__ = ['Light', 'DirectionalLight', 'SpotLight', 'PointLight']