pyrender-maintained 1.0.0__tar.gz

pyrender_maintained-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Matthew Matl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyrender_maintained-1.0.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: pyrender-maintained
+Version: 1.0.0
+Summary: Easy-to-use Python renderer for 3D visualization (maintained fork)
+Home-page: https://github.com/SimonKim4100/pyrender-maintained
+Author: Simon Kim
+Author-email: hohosemin@gmail.com
+License: MIT License
+Keywords: rendering graphics opengl 3d visualization pbr gltf
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Natural Language :: English
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: freetype-py
+Requires-Dist: imageio
+Requires-Dist: networkx
+Requires-Dist: numpy>=2.0
+Requires-Dist: Pillow
+Requires-Dist: pyglet>=2.0
+Requires-Dist: PyOpenGL>=3.1.0
+Requires-Dist: scipy
+Requires-Dist: trimesh
+Provides-Extra: dev
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: tox; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Requires-Dist: sphinx-automodapi; extra == "docs"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+A maintained fork of pyrender — a simple implementation of Physically-Based Rendering (PBR) in Python. Compliant with the glTF 2.0 standard. Supports modern Python (3.11+) and NumPy 2.x.

pyrender_maintained-1.0.0/README.md

@@ -0,0 +1,2 @@
+# Pyrender
+Maintained version of pyrender to work on recent python, numpy versions

pyrender_maintained-1.0.0/pyrender/__init__.py

@@ -0,0 +1,24 @@
+from .camera import (Camera, PerspectiveCamera, OrthographicCamera,
+                     IntrinsicsCamera)
+from .light import Light, PointLight, DirectionalLight, SpotLight
+from .sampler import Sampler
+from .texture import Texture
+from .material import Material, MetallicRoughnessMaterial
+from .primitive import Primitive
+from .mesh import Mesh
+from .node import Node
+from .scene import Scene
+from .renderer import Renderer
+from .viewer import Viewer
+from .offscreen import OffscreenRenderer
+from .version import __version__
+from .constants import RenderFlags, TextAlign, GLTF
+
+__all__ = [
+    'Camera', 'PerspectiveCamera', 'OrthographicCamera', 'IntrinsicsCamera',
+    'Light', 'PointLight', 'DirectionalLight', 'SpotLight',
+    'Sampler', 'Texture', 'Material', 'MetallicRoughnessMaterial',
+    'Primitive', 'Mesh', 'Node', 'Scene', 'Renderer', 'Viewer',
+    'OffscreenRenderer', '__version__', 'RenderFlags', 'TextAlign',
+    'GLTF'
+]

pyrender_maintained-1.0.0/pyrender/camera.py

@@ -0,0 +1,435 @@
+"""Virtual cameras compliant with the glTF 2.0 specification as described at
+https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-camera
+
+Author: Matthew Matl
+"""
+import abc
+import numpy as np
+import sys
+
+from .constants import DEFAULT_Z_NEAR, DEFAULT_Z_FAR
+
+
+class Camera(abc.ABC):
+    """Abstract base class for all cameras.
+
+    Note
+    ----
+    Camera poses are specified in the OpenGL format,
+    where the z axis points away from the view direction and the
+    x and y axes point to the right and up in the image plane, respectively.
+
+    Parameters
+    ----------
+    znear : float
+        The floating-point distance to the near clipping plane.
+    zfar : float
+        The floating-point distance to the far clipping plane.
+        ``zfar`` must be greater than ``znear``.
+    name : str, optional
+        The user-defined name of this object.
+    """
+
+    def __init__(self,
+                 znear=DEFAULT_Z_NEAR,
+                 zfar=DEFAULT_Z_FAR,
+                 name=None):
+        self.name = name
+        self.znear = znear
+        self.zfar = zfar
+
+    @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 znear(self):
+        """float : The distance to the near clipping plane.
+        """
+        return self._znear
+
+    @znear.setter
+    def znear(self, value):
+        value = float(value)
+        if value < 0:
+            raise ValueError('z-near must be >= 0.0')
+        self._znear = value
+
+    @property
+    def zfar(self):
+        """float : The distance to the far clipping plane.
+        """
+        return self._zfar
+
+    @zfar.setter
+    def zfar(self, value):
+        value = float(value)
+        if value <= 0 or value <= self.znear:
+            raise ValueError('zfar must be >0 and >znear')
+        self._zfar = value
+
+    @abc.abstractmethod
+    def get_projection_matrix(self, width=None, height=None):
+        """Return the OpenGL projection matrix for this camera.
+
+        Parameters
+        ----------
+        width : int
+            Width of the current viewport, in pixels.
+        height : int
+            Height of the current viewport, in pixels.
+        """
+        pass
+
+
+class PerspectiveCamera(Camera):
+
+    """A perspective camera for perspective projection.
+
+    Parameters
+    ----------
+    yfov : float
+        The floating-point vertical field of view in radians.
+    znear : float
+        The floating-point distance to the near clipping plane.
+        If not specified, defaults to 0.05.
+    zfar : float, optional
+        The floating-point distance to the far clipping plane.
+        ``zfar`` must be greater than ``znear``.
+        If None, the camera uses an infinite projection matrix.
+    aspectRatio : float, optional
+        The floating-point aspect ratio of the field of view.
+        If not specified, the camera uses the viewport's aspect ratio.
+    name : str, optional
+        The user-defined name of this object.
+    """
+
+    def __init__(self,
+                 yfov,
+                 znear=DEFAULT_Z_NEAR,
+                 zfar=None,
+                 aspectRatio=None,
+                 name=None):
+        super(PerspectiveCamera, self).__init__(
+            znear=znear,
+            zfar=zfar,
+            name=name,
+        )
+
+        self.yfov = yfov
+        self.aspectRatio = aspectRatio
+
+    @property
+    def yfov(self):
+        """float : The vertical field of view in radians.
+        """
+        return self._yfov
+
+    @yfov.setter
+    def yfov(self, value):
+        value = float(value)
+        if value <= 0.0:
+            raise ValueError('Field of view must be positive')
+        self._yfov = value
+
+    @property
+    def zfar(self):
+        """float : The distance to the far clipping plane.
+        """
+        return self._zfar
+
+    @zfar.setter
+    def zfar(self, value):
+        if value is not None:
+            value = float(value)
+            if value <= 0 or value <= self.znear:
+                raise ValueError('zfar must be >0 and >znear')
+        self._zfar = value
+
+    @property
+    def aspectRatio(self):
+        """float : The ratio of the width to the height of the field of view.
+        """
+        return self._aspectRatio
+
+    @aspectRatio.setter
+    def aspectRatio(self, value):
+        if value is not None:
+            value = float(value)
+            if value <= 0.0:
+                raise ValueError('Aspect ratio must be positive')
+        self._aspectRatio = value
+
+    def get_projection_matrix(self, width=None, height=None):
+        """Return the OpenGL projection matrix for this camera.
+
+        Parameters
+        ----------
+        width : int
+            Width of the current viewport, in pixels.
+        height : int
+            Height of the current viewport, in pixels.
+        """
+        aspect_ratio = self.aspectRatio
+        if aspect_ratio is None:
+            if width is None or height is None:
+                raise ValueError('Aspect ratio of camera must be defined')
+            aspect_ratio = float(width) / float(height)
+
+        a = aspect_ratio
+        t = np.tan(self.yfov / 2.0)
+        n = self.znear
+        f = self.zfar
+
+        P = np.zeros((4,4))
+        P[0][0] = 1.0 / (a * t)
+        P[1][1] = 1.0 / t
+        P[3][2] = -1.0
+
+        if f is None:
+            P[2][2] = -1.0
+            P[2][3] = -2.0 * n
+        else:
+            P[2][2] = (f + n) / (n - f)
+            P[2][3] = (2 * f * n) / (n - f)
+
+        return P
+
+
+class OrthographicCamera(Camera):
+    """An orthographic camera for orthographic projection.
+
+    Parameters
+    ----------
+    xmag : float
+        The floating-point horizontal magnification of the view.
+    ymag : float
+        The floating-point vertical magnification of the view.
+    znear : float
+        The floating-point distance to the near clipping plane.
+        If not specified, defaults to 0.05.
+    zfar : float
+        The floating-point distance to the far clipping plane.
+        ``zfar`` must be greater than ``znear``.
+        If not specified, defaults to 100.0.
+    name : str, optional
+        The user-defined name of this object.
+    """
+
+    def __init__(self,
+                 xmag,
+                 ymag,
+                 znear=DEFAULT_Z_NEAR,
+                 zfar=DEFAULT_Z_FAR,
+                 name=None):
+        super(OrthographicCamera, self).__init__(
+            znear=znear,
+            zfar=zfar,
+            name=name,
+        )
+
+        self.xmag = xmag
+        self.ymag = ymag
+
+    @property
+    def xmag(self):
+        """float : The horizontal magnification of the view.
+        """
+        return self._xmag
+
+    @xmag.setter
+    def xmag(self, value):
+        value = float(value)
+        if value <= 0.0:
+            raise ValueError('X magnification must be positive')
+        self._xmag = value
+
+    @property
+    def ymag(self):
+        """float : The vertical magnification of the view.
+        """
+        return self._ymag
+
+    @ymag.setter
+    def ymag(self, value):
+        value = float(value)
+        if value <= 0.0:
+            raise ValueError('Y magnification must be positive')
+        self._ymag = value
+
+    @property
+    def znear(self):
+        """float : The distance to the near clipping plane.
+        """
+        return self._znear
+
+    @znear.setter
+    def znear(self, value):
+        value = float(value)
+        if value <= 0:
+            raise ValueError('z-near must be > 0.0')
+        self._znear = value
+
+    def get_projection_matrix(self, width=None, height=None):
+        """Return the OpenGL projection matrix for this camera.
+
+        Parameters
+        ----------
+        width : int
+            Width of the current viewport, in pixels.
+            Unused in this function.
+        height : int
+            Height of the current viewport, in pixels.
+            Unused in this function.
+        """
+        xmag = self.xmag
+        ymag = self.ymag
+
+        # If screen width/height defined, rescale xmag
+        if width is not None and height is not None:
+            xmag = width / height * ymag
+
+        n = self.znear
+        f = self.zfar
+        P = np.zeros((4,4))
+        P[0][0] = 1.0 / xmag
+        P[1][1] = 1.0 / ymag
+        P[2][2] = 2.0 / (n - f)
+        P[2][3] = (f + n) / (n - f)
+        P[3][3] = 1.0
+        return P
+
+
+class IntrinsicsCamera(Camera):
+    """A perspective camera with custom intrinsics.
+
+    Parameters
+    ----------
+    fx : float
+        X-axis focal length in pixels.
+    fy : float
+        Y-axis focal length in pixels.
+    cx : float
+        X-axis optical center in pixels.
+    cy : float
+        Y-axis optical center in pixels.
+    znear : float
+        The floating-point distance to the near clipping plane.
+        If not specified, defaults to 0.05.
+    zfar : float
+        The floating-point distance to the far clipping plane.
+        ``zfar`` must be greater than ``znear``.
+        If not specified, defaults to 100.0.
+    name : str, optional
+        The user-defined name of this object.
+    """
+
+    def __init__(self,
+                 fx,
+                 fy,
+                 cx,
+                 cy,
+                 znear=DEFAULT_Z_NEAR,
+                 zfar=DEFAULT_Z_FAR,
+                 name=None):
+        super(IntrinsicsCamera, self).__init__(
+            znear=znear,
+            zfar=zfar,
+            name=name,
+        )
+
+        self.fx = fx
+        self.fy = fy
+        self.cx = cx
+        self.cy = cy
+
+    @property
+    def fx(self):
+        """float : X-axis focal length in meters.
+        """
+        return self._fx
+
+    @fx.setter
+    def fx(self, value):
+        self._fx = float(value)
+
+    @property
+    def fy(self):
+        """float : Y-axis focal length in meters.
+        """
+        return self._fy
+
+    @fy.setter
+    def fy(self, value):
+        self._fy = float(value)
+
+    @property
+    def cx(self):
+        """float : X-axis optical center in pixels.
+        """
+        return self._cx
+
+    @cx.setter
+    def cx(self, value):
+        self._cx = float(value)
+
+    @property
+    def cy(self):
+        """float : Y-axis optical center in pixels.
+        """
+        return self._cy
+
+    @cy.setter
+    def cy(self, value):
+        self._cy = float(value)
+
+    def get_projection_matrix(self, width, height):
+        """Return the OpenGL projection matrix for this camera.
+
+        Parameters
+        ----------
+        width : int
+            Width of the current viewport, in pixels.
+        height : int
+            Height of the current viewport, in pixels.
+        """
+        width = float(width)
+        height = float(height)
+
+        cx, cy = self.cx, self.cy
+        fx, fy = self.fx, self.fy
+        if sys.platform == 'darwin':
+            cx = self.cx * 2.0
+            cy = self.cy * 2.0
+            fx = self.fx * 2.0
+            fy = self.fy * 2.0
+
+        P = np.zeros((4,4))
+        P[0][0] = 2.0 * fx / width
+        P[1][1] = 2.0 * fy / height
+        P[0][2] = 1.0 - 2.0 * cx / width
+        P[1][2] = 2.0 * cy / height - 1.0
+        P[3][2] = -1.0
+
+        n = self.znear
+        f = self.zfar
+        if f is None:
+            P[2][2] = -1.0
+            P[2][3] = -2.0 * n
+        else:
+            P[2][2] = (f + n) / (n - f)
+            P[2][3] = (2 * f * n) / (n - f)
+
+        return P
+
+
+__all__ = ['Camera', 'PerspectiveCamera', 'OrthographicCamera',
+           'IntrinsicsCamera']

pyrender_maintained-1.0.0/pyrender/constants.py

@@ -0,0 +1,149 @@
+DEFAULT_Z_NEAR = 0.05     # Near clipping plane, in meters
+DEFAULT_Z_FAR = 100.0     # Far clipping plane, in meters
+DEFAULT_SCENE_SCALE = 2.0 # Default scene scale
+MAX_N_LIGHTS = 4          # Maximum number of lights of each type allowed
+TARGET_OPEN_GL_MAJOR = 4  # Target OpenGL Major Version
+TARGET_OPEN_GL_MINOR = 1  # Target OpenGL Minor Version
+MIN_OPEN_GL_MAJOR = 3     # Minimum OpenGL Major Version
+MIN_OPEN_GL_MINOR = 3     # Minimum OpenGL Minor Version
+FLOAT_SZ = 4              # Byte size of GL float32
+UINT_SZ = 4               # Byte size of GL uint32
+SHADOW_TEX_SZ = 2048      # Width and Height of Shadow Textures
+TEXT_PADDING = 20         # Width of padding for rendering text (px)
+
+
+# Flags for render type
+class RenderFlags(object):
+    """Flags for rendering in the scene.
+
+    Combine them with the bitwise or. For example,
+
+    >>> flags = OFFSCREEN | SHADOWS_DIRECTIONAL | VERTEX_NORMALS
+
+    would result in an offscreen render with directional shadows and
+    vertex normals enabled.
+    """
+    NONE = 0
+    """Normal PBR Render."""
+    DEPTH_ONLY = 1
+    """Only render the depth buffer."""
+    OFFSCREEN = 2
+    """Render offscreen and return the depth and (optionally) color buffers."""
+    FLIP_WIREFRAME = 4
+    """Invert the status of wireframe rendering for each mesh."""
+    ALL_WIREFRAME = 8
+    """Render all meshes as wireframes."""
+    ALL_SOLID = 16
+    """Render all meshes as solids."""
+    SHADOWS_DIRECTIONAL = 32
+    """Render shadows for directional lights."""
+    SHADOWS_POINT = 64
+    """Render shadows for point lights."""
+    SHADOWS_SPOT = 128
+    """Render shadows for spot lights."""
+    SHADOWS_ALL = 32 | 64 | 128
+    """Render shadows for all lights."""
+    VERTEX_NORMALS = 256
+    """Render vertex normals."""
+    FACE_NORMALS = 512
+    """Render face normals."""
+    SKIP_CULL_FACES = 1024
+    """Do not cull back faces."""
+    RGBA = 2048
+    """Render the color buffer with the alpha channel enabled."""
+    FLAT = 4096
+    """Render the color buffer flat, with no lighting computations."""
+    SEG = 8192
+
+
+class TextAlign:
+    """Text alignment options for captions.
+
+    Only use one at a time.
+    """
+    CENTER = 0
+    """Center the text by width and height."""
+    CENTER_LEFT = 1
+    """Center the text by height and left-align it."""
+    CENTER_RIGHT = 2
+    """Center the text by height and right-align it."""
+    BOTTOM_LEFT = 3
+    """Put the text in the bottom-left corner."""
+    BOTTOM_RIGHT = 4
+    """Put the text in the bottom-right corner."""
+    BOTTOM_CENTER = 5
+    """Center the text by width and fix it to the bottom."""
+    TOP_LEFT = 6
+    """Put the text in the top-left corner."""
+    TOP_RIGHT = 7
+    """Put the text in the top-right corner."""
+    TOP_CENTER = 8
+    """Center the text by width and fix it to the top."""
+
+
+class GLTF(object):
+    """Options for GL objects."""
+    NEAREST = 9728
+    """Nearest neighbor interpolation."""
+    LINEAR = 9729
+    """Linear interpolation."""
+    NEAREST_MIPMAP_NEAREST = 9984
+    """Nearest mipmapping."""
+    LINEAR_MIPMAP_NEAREST = 9985
+    """Linear mipmapping."""
+    NEAREST_MIPMAP_LINEAR = 9986
+    """Nearest mipmapping."""
+    LINEAR_MIPMAP_LINEAR = 9987
+    """Linear mipmapping."""
+    CLAMP_TO_EDGE = 33071
+    """Clamp to the edge of the texture."""
+    MIRRORED_REPEAT = 33648
+    """Mirror the texture."""
+    REPEAT = 10497
+    """Repeat the texture."""
+    POINTS = 0
+    """Render as points."""
+    LINES = 1
+    """Render as lines."""
+    LINE_LOOP = 2
+    """Render as a line loop."""
+    LINE_STRIP = 3
+    """Render as a line strip."""
+    TRIANGLES = 4
+    """Render as triangles."""
+    TRIANGLE_STRIP = 5
+    """Render as a triangle strip."""
+    TRIANGLE_FAN = 6
+    """Render as a triangle fan."""
+
+
+class BufFlags(object):
+    POSITION = 0
+    NORMAL = 1
+    TANGENT = 2
+    TEXCOORD_0 = 4
+    TEXCOORD_1 = 8
+    COLOR_0 = 16
+    JOINTS_0 = 32
+    WEIGHTS_0 = 64
+
+
+class TexFlags(object):
+    NONE = 0
+    NORMAL = 1
+    OCCLUSION = 2
+    EMISSIVE = 4
+    BASE_COLOR = 8
+    METALLIC_ROUGHNESS = 16
+    DIFFUSE = 32
+    SPECULAR_GLOSSINESS = 64
+
+
+class ProgramFlags:
+    NONE = 0
+    USE_MATERIAL = 1
+    VERTEX_NORMALS = 2
+    FACE_NORMALS = 4
+
+
+__all__ = ['RenderFlags', 'TextAlign', 'GLTF']