First commit

pyrender/.coveragerc

@@ -0,0 +1,5 @@
+[report]
+exclude_lines =
+    def __repr__
+    def __str__
+    @abc.abstractmethod

pyrender/.flake8

@@ -0,0 +1,8 @@
+[flake8]
+ignore = E231,W504,F405,F403
+max-line-length = 79
+select = B,C,E,F,W,T4,B9
+exclude = 
+    docs/source/conf.py,
+    __pycache__,
+    examples/*

pyrender/.gitignore

@@ -0,0 +1,106 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+docs/**/generated/**
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/

pyrender/.pre-commit-config.yaml

@@ -0,0 +1,6 @@
+repos:
+- repo: https://gitlab.com/pycqa/flake8
+  rev: 3.7.1
+  hooks:
+    - id: flake8
+      exclude: ^setup.py

pyrender/.travis.yml

@@ -0,0 +1,43 @@
+language: python
+sudo: required
+dist: xenial
+
+python:
+- '3.6'
+- '3.7'
+
+before_install:
+  # Pre-install osmesa
+  - sudo apt update
+  - sudo wget https://github.com/mmatl/travis_debs/raw/master/xenial/mesa_18.3.3-0.deb
+  - sudo dpkg -i ./mesa_18.3.3-0.deb || true
+  - sudo apt install -f
+  - git clone https://github.com/mmatl/pyopengl.git
+  - cd pyopengl
+  - pip install .
+  - cd ..
+
+install:
+  - pip install .
+    #  - pip install -q pytest pytest-cov coveralls
+  - pip install pytest pytest-cov coveralls
+  - pip install ./pyopengl
+
+script:
+  - PYOPENGL_PLATFORM=osmesa pytest --cov=pyrender tests
+
+after_success:
+- coveralls || true
+
+deploy:
+  provider: pypi
+  skip_existing: true
+  user: mmatl
+  on:
+    tags: true
+    branch: master
+  password:
+    secure: O4WWMbTYb2eVYIO4mMOVa6/xyhX7mPvJpd96cxfNvJdyuqho8VapOhzqsI5kahMB1hFjWWr61yR4+Ru5hoDYf3XA6BQVk8eCY9+0H7qRfvoxex71lahKAqfHLMoE1xNdiVTgl+QN9hYjOnopLod24rx8I8eXfpHu/mfCpuTYGyLlNcDP5St3bXpXLPB5wg8Jo1YRRv6W/7fKoXyuWjewk9cJAS0KrEgnDnSkdwm6Pb+80B2tcbgdGvpGaByw5frndwKiMUMgVUownepDU5POQq2p29wwn9lCvRucULxjEgO+63jdbZRj5fNutLarFa2nISfYnrd72LOyDfbJubwAzzAIsy2JbFORyeHvCgloiuE9oE7a9oOQt/1QHBoIV0seiawMWn55Yp70wQ7HlJs4xSGJWCGa5+9883QRNsvj420atkb3cgO8P+PXwiwTi78Dq7Z/xHqccsU0b8poqBneQoA+pUGgNnF6V7Z8e9RsCcse2gAWSZWuOK3ua+9xCgH7I7MeL3afykr2aJ+yFCoYJMFrUjJeodMX2RbL0q+3FzIPZeGW3WdhTEAL9TSKRcJBSQTskaQlZx/OcpobxS7t3d2S68CCLG9uMTqOTYws55WZ1etalA75sRk9K2MR7ZGjZW3jdtvMViISc/t6Rrjea1GE8ZHGJC6/IeLIWA2c7nc=
+  distributions: sdist bdist_wheel
+notifications:
+  email: false

pyrender/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/MANIFEST.in

@@ -0,0 +1,5 @@
+# Include the license
+include LICENSE
+include README.rst
+include pyrender/fonts/*
+include pyrender/shaders/*

pyrender/README.md

@@ -0,0 +1,92 @@
+# Pyrender
+
+[![Build Status](https://travis-ci.org/mmatl/pyrender.svg?branch=master)](https://travis-ci.org/mmatl/pyrender)
+[![Documentation Status](https://readthedocs.org/projects/pyrender/badge/?version=latest)](https://pyrender.readthedocs.io/en/latest/?badge=latest)
+[![Coverage Status](https://coveralls.io/repos/github/mmatl/pyrender/badge.svg?branch=master)](https://coveralls.io/github/mmatl/pyrender?branch=master)
+[![PyPI version](https://badge.fury.io/py/pyrender.svg)](https://badge.fury.io/py/pyrender)
+[![Downloads](https://pepy.tech/badge/pyrender)](https://pepy.tech/project/pyrender)
+
+Pyrender is a pure Python (2.7, 3.4, 3.5, 3.6) library for physically-based
+rendering and visualization.
+It is designed to meet the [glTF 2.0 specification from Khronos](https://www.khronos.org/gltf/).
+
+Pyrender is lightweight, easy to install, and simple to use.
+It comes packaged with both an intuitive scene viewer and a headache-free
+offscreen renderer with support for GPU-accelerated rendering on headless
+servers, which makes it perfect for machine learning applications.
+
+Extensive documentation, including a quickstart guide, is provided [here](https://pyrender.readthedocs.io/en/latest/).
+
+For a minimal working example of GPU-accelerated offscreen rendering using EGL,
+check out the [EGL Google CoLab Notebook](https://colab.research.google.com/drive/1pcndwqeY8vker3bLKQNJKr3B-7-SYenE?usp=sharing).
+
+
+<p align="center">
+  <img width="48%" src="https://github.com/mmatl/pyrender/blob/master/docs/source/_static/rotation.gif?raw=true" alt="GIF of Viewer"/>
+  <img width="48%" src="https://github.com/mmatl/pyrender/blob/master/docs/source/_static/damaged_helmet.png?raw=true" alt="Damaged Helmet"/>
+</p>
+
+## Installation
+You can install pyrender directly from pip.
+
+```bash
+pip install pyrender
+```
+
+## Features
+
+Despite being lightweight, pyrender has lots of features, including:
+
+* Simple interoperation with the amazing [trimesh](https://github.com/mikedh/trimesh) project,
+which enables out-of-the-box support for dozens of mesh types, including OBJ,
+STL, DAE, OFF, PLY, and GLB.
+* An easy-to-use scene viewer with support for animation, showing face and vertex
+normals, toggling lighting conditions, and saving images and GIFs.
+* An offscreen rendering module that supports OSMesa and EGL backends.
+* Shadow mapping for directional and spot lights.
+* Metallic-roughness materials for physically-based rendering, including several
+types of texture and normal mapping.
+* Transparency.
+* Depth and color image generation.
+
+## Sample Usage
+
+For sample usage, check out the [quickstart
+guide](https://pyrender.readthedocs.io/en/latest/examples/index.html) or one of
+the Google CoLab Notebooks:
+
+* [EGL Google CoLab Notebook](https://colab.research.google.com/drive/1pcndwqeY8vker3bLKQNJKr3B-7-SYenE?usp=sharing)
+
+## Viewer Keyboard and Mouse Controls
+
+When using the viewer, the basic controls for moving about the scene are as follows:
+
+* To rotate the camera about the center of the scene, hold the left mouse button and drag the cursor.
+* To rotate the camera about its viewing axis, hold `CTRL` left mouse button and drag the cursor.
+* To pan the camera, do one of the following:
+    * Hold `SHIFT`, then hold the left mouse button and drag the cursor.
+    * Hold the middle mouse button and drag the cursor.
+* To zoom the camera in or out, do one of the following:
+    * Scroll the mouse wheel.
+    * Hold the right mouse button and drag the cursor.
+
+The available keyboard commands are as follows:
+
+* `a`: Toggles rotational animation mode.
+* `c`: Toggles backface culling.
+* `f`: Toggles fullscreen mode.
+* `h`: Toggles shadow rendering.
+* `i`: Toggles axis display mode (no axes, world axis, mesh axes, all axes).
+* `l`: Toggles lighting mode (scene lighting, Raymond lighting, or direct lighting).
+* `m`: Toggles face normal visualization.
+* `n`: Toggles vertex normal visualization.
+* `o`: Toggles orthographic camera mode.
+* `q`: Quits the viewer.
+* `r`: Starts recording a GIF, and pressing again stops recording and opens a file dialog.
+* `s`: Opens a file dialog to save the current view as an image.
+* `w`: Toggles wireframe mode (scene default, flip wireframes, all wireframe, or all solid).
+* `z`: Resets the camera to the default view.
+
+As a note, displaying shadows significantly slows down rendering, so if you're
+experiencing low framerates, just kill shadows or reduce the number of lights in
+your scene.

pyrender/docs/Makefile

@@ -0,0 +1,23 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+clean:
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+	rm -rf ./source/generated/*
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

pyrender/docs/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+:end
+popd

pyrender/docs/source/api/index.rst

@@ -0,0 +1,59 @@
+Pyrender API Documentation
+==========================
+
+Constants
+---------
+.. automodapi:: pyrender.constants
+   :no-inheritance-diagram:
+   :no-main-docstr:
+   :no-heading:
+
+Cameras
+-------
+.. automodapi:: pyrender.camera
+   :no-inheritance-diagram:
+   :no-main-docstr:
+   :no-heading:
+
+Lighting
+--------
+.. automodapi:: pyrender.light
+   :no-inheritance-diagram:
+   :no-main-docstr:
+   :no-heading:
+
+Objects
+-------
+.. automodapi:: pyrender
+   :no-inheritance-diagram:
+   :no-main-docstr:
+   :no-heading:
+   :skip: Camera, DirectionalLight, Light, OffscreenRenderer, Node
+   :skip: OrthographicCamera, PerspectiveCamera, PointLight, RenderFlags
+   :skip: Renderer, Scene, SpotLight, TextAlign, Viewer, GLTF
+
+Scenes
+------
+.. automodapi:: pyrender
+   :no-inheritance-diagram:
+   :no-main-docstr:
+   :no-heading:
+   :skip: Camera, DirectionalLight, Light, OffscreenRenderer
+   :skip: OrthographicCamera, PerspectiveCamera, PointLight, RenderFlags
+   :skip: Renderer, SpotLight, TextAlign, Viewer, Sampler, Texture, Material
+   :skip: MetallicRoughnessMaterial, Primitive, Mesh, GLTF
+
+On-Screen Viewer
+----------------
+.. automodapi:: pyrender.viewer
+   :no-inheritance-diagram:
+   :no-inherited-members:
+   :no-main-docstr:
+   :no-heading:
+
+Off-Screen Rendering
+--------------------
+.. automodapi:: pyrender.offscreen
+   :no-inheritance-diagram:
+   :no-main-docstr:
+   :no-heading:

pyrender/docs/source/conf.py

@@ -0,0 +1,352 @@
+# -*- coding: utf-8 -*-
+#
+# core documentation build configuration file, created by
+# sphinx-quickstart on Sun Oct 16 14:33:48 2016.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys
+import os
+from pyrender import __version__
+from sphinx.domains.python import PythonDomain
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+sys.path.insert(0, os.path.abspath('../../'))
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.autosummary',
+    'sphinx.ext.coverage',
+    'sphinx.ext.githubpages',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.viewcode',
+    'sphinx_automodapi.automodapi',
+    'sphinx_automodapi.smart_resolver'
+]
+numpydoc_class_members_toctree = False
+automodapi_toctreedirnm = 'generated'
+automodsumm_inherited_members = True
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'pyrender'
+copyright = u'2018, Matthew Matl'
+author = u'Matthew Matl'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = __version__
+# The full version, including alpha/beta/rc tags.
+release = __version__
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = []
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+#keep_warnings = False
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+import sphinx_rtd_theme
+html_theme = 'sphinx_rtd_theme'
+html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+#html_theme_path = []
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (relative to this directory) to use as a favicon of
+# the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+#html_extra_path = []
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_domain_indices = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = None
+
+# Language to be used for generating the HTML full-text search index.
+# Sphinx supports the following languages:
+#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
+#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
+#html_search_language = 'en'
+
+# A dictionary with options for the search language support, empty by default.
+# Now only 'ja' uses this config value
+#html_search_options = {'type': 'default'}
+
+# The name of a javascript file (relative to the configuration directory) that
+# implements a search results scorer. If empty, the default will be used.
+#html_search_scorer = 'scorer.js'
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'coredoc'
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+# The paper size ('letterpaper' or 'a4paper').
+#'papersize': 'letterpaper',
+
+# The font size ('10pt', '11pt' or '12pt').
+#'pointsize': '10pt',
+
+# Additional stuff for the LaTeX preamble.
+#'preamble': '',
+
+# Latex figure (float) alignment
+#'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (master_doc, 'pyrender.tex', u'pyrender Documentation',
+     u'Matthew Matl', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# If true, show page references after internal links.
+#latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_domain_indices = True
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'pyrender', u'pyrender Documentation',
+     [author], 1)
+]
+
+# If true, show URL addresses after external links.
+#man_show_urls = False
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc, 'pyrender', u'pyrender Documentation',
+     author, 'pyrender', 'One line description of project.',
+     'Miscellaneous'),
+]
+
+# Documents to append as an appendix to all manuals.
+#texinfo_appendices = []
+
+# If false, no module index is generated.
+#texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#texinfo_show_urls = 'footnote'
+
+# If true, do not generate a @detailmenu in the "Top" node's menu.
+#texinfo_no_detailmenu = False
+
+intersphinx_mapping = {
+    'python' : ('https://docs.python.org/', None),
+    'pyrender' : ('https://pyrender.readthedocs.io/en/latest/', None),
+}
+
+# Autosummary fix
+autosummary_generate = True
+
+# Try to suppress multiple-definition warnings by always taking the shorter
+# path when two or more paths have the same base module
+
+class MyPythonDomain(PythonDomain):
+
+    def find_obj(self, env, modname, classname, name, type, searchmode=0):
+        """Ensures an object always resolves to the desired module
+        if defined there."""
+        orig_matches = PythonDomain.find_obj(
+            self, env, modname, classname, name, type, searchmode
+        )
+
+        if len(orig_matches) <= 1:
+            return orig_matches
+
+        # If multiple matches, try to take the shortest if all the modules are
+        # the same
+        first_match_name_sp = orig_matches[0][0].split('.')
+        base_name = first_match_name_sp[0]
+        min_len = len(first_match_name_sp)
+        best_match = orig_matches[0]
+
+        for match in orig_matches[1:]:
+            match_name = match[0]
+            match_name_sp = match_name.split('.')
+            match_base = match_name_sp[0]
+
+            # If we have mismatched bases, return them all to trigger warnings
+            if match_base != base_name:
+                return orig_matches
+
+            # Otherwise, check and see if it's shorter
+            if len(match_name_sp) < min_len:
+                min_len = len(match_name_sp)
+                best_match = match
+
+        return (best_match,)
+
+
+def setup(sphinx):
+    """Use MyPythonDomain in place of PythonDomain"""
+    sphinx.override_domain(MyPythonDomain)
+

pyrender/docs/source/examples/cameras.rst

@@ -0,0 +1,26 @@
+.. _camera_guide:
+
+Creating Cameras
+================
+
+Pyrender supports three camera types -- :class:`.PerspectiveCamera` and
+:class:`.IntrinsicsCamera` types,
+which render scenes as a human would see them, and
+:class:`.OrthographicCamera` types, which preserve distances between points.
+
+Creating cameras is easy -- just specify their basic attributes:
+
+>>> pc = pyrender.PerspectiveCamera(yfov=np.pi / 3.0, aspectRatio=1.414)
+>>> oc = pyrender.OrthographicCamera(xmag=1.0, ymag=1.0)
+
+For more information, see the Khronos group's documentation here_:
+
+.. _here: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#projection-matrices
+
+When you add cameras to the scene, make sure that you're using OpenGL camera
+coordinates to specify their pose. See the illustration below for details.
+Basically, the camera z-axis points away from the scene, the x-axis points
+right in image space, and the y-axis points up in image space.
+
+.. image:: /_static/camera_coords.png
+

pyrender/docs/source/examples/index.rst

@@ -0,0 +1,20 @@
+.. _guide:
+
+User Guide
+==========
+
+This section contains guides on how to use Pyrender to quickly visualize
+your 3D data, including a quickstart guide and more detailed descriptions
+of each part of the rendering pipeline.
+
+
+.. toctree::
+   :maxdepth: 2
+
+   quickstart.rst
+   models.rst
+   lighting.rst
+   cameras.rst
+   scenes.rst
+   offscreen.rst
+   viewer.rst

pyrender/docs/source/examples/lighting.rst

@@ -0,0 +1,21 @@
+.. _lighting_guide:
+
+Creating Lights
+===============
+
+Pyrender supports three types of punctual light:
+
+- :class:`.PointLight`: Point-based light sources, such as light bulbs.
+- :class:`.SpotLight`: A conical light source, like a flashlight.
+- :class:`.DirectionalLight`: A general light that does not attenuate with
+  distance.
+
+Creating lights is easy -- just specify their basic attributes:
+
+>>> pl = pyrender.PointLight(color=[1.0, 1.0, 1.0], intensity=2.0)
+>>> sl = pyrender.SpotLight(color=[1.0, 1.0, 1.0], intensity=2.0,
+...                         innerConeAngle=0.05, outerConeAngle=0.5)
+>>> dl = pyrender.DirectionalLight(color=[1.0, 1.0, 1.0], intensity=2.0)
+
+For more information about how these lighting models are implemented,
+see their class documentation.

pyrender/docs/source/examples/models.rst

@@ -0,0 +1,143 @@
+.. _model_guide:
+
+Loading and Configuring Models
+==============================
+The first step to any rendering application is loading your models.
+Pyrender implements the GLTF 2.0 specification, which means that all
+models are composed of a hierarchy of objects.
+
+At the top level, we have a :class:`.Mesh`. The :class:`.Mesh` is
+basically a wrapper of any number of :class:`.Primitive` types,
+which actually represent geometry that can be drawn to the screen.
+
+Primitives are composed of a variety of parameters, including
+vertex positions, vertex normals, color and texture information,
+and triangle indices if smooth rendering is desired.
+They can implement point clouds, triangular meshes, or lines
+depending on how you configure their data and set their
+:attr:`.Primitive.mode` parameter.
+
+Although you can create primitives yourself if you want to,
+it's probably easier to just use the utility functions provided
+in the :class:`.Mesh` class.
+
+Creating Triangular Meshes
+--------------------------
+
+Simple Construction
+~~~~~~~~~~~~~~~~~~~
+Pyrender allows you to create a :class:`.Mesh` containing a
+triangular mesh model directly from a :class:`~trimesh.base.Trimesh` object
+using the :meth:`.Mesh.from_trimesh` static method.
+
+>>> import trimesh
+>>> import pyrender
+>>> import numpy as np
+>>> tm = trimesh.load('examples/models/fuze.obj')
+>>> m = pyrender.Mesh.from_trimesh(tm)
+>>> m.primitives
+[<pyrender.primitive.Primitive at 0x7fbb0af60e50>]
+
+You can also create a single :class:`.Mesh` from a list of
+:class:`~trimesh.base.Trimesh` objects:
+
+>>> tms = [trimesh.creation.icosahedron(), trimesh.creation.cylinder()]
+>>> m = pyrender.Mesh.from_trimesh(tms)
+[<pyrender.primitive.Primitive at 0x7fbb0c2b74d0>,
+ <pyrender.primitive.Primitive at 0x7fbb0c2b7550>]
+
+Vertex Smoothing
+~~~~~~~~~~~~~~~~
+
+The :meth:`.Mesh.from_trimesh` method has a few additional optional parameters.
+If you want to render the mesh without interpolating face normals, which can
+be useful for meshes that are supposed to be angular (e.g. a cube), you
+can specify ``smooth=False``.
+
+>>> m = pyrender.Mesh.from_trimesh(tm, smooth=False)
+
+Per-Face or Per-Vertex Coloration
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you have an untextured trimesh, you can color it in with per-face or
+per-vertex colors:
+
+>>> tm.visual.vertex_colors = np.random.uniform(size=tm.vertices.shape)
+>>> tm.visual.face_colors = np.random.uniform(size=tm.faces.shape)
+>>> m = pyrender.Mesh.from_trimesh(tm)
+
+Instancing
+~~~~~~~~~~
+
+If you want to render many copies of the same mesh at different poses,
+you can statically create a vast array of them in an efficient manner.
+Simply specify the ``poses`` parameter to be a list of ``N`` 4x4 homogenous
+transformation matrics that position the meshes relative to their common
+base frame:
+
+>>> tfs = np.tile(np.eye(4), (3,1,1))
+>>> tfs[1,:3,3] = [0.1, 0.0, 0.0]
+>>> tfs[2,:3,3] = [0.2, 0.0, 0.0]
+>>> tfs
+array([[[1. , 0. , 0. , 0. ],
+        [0. , 1. , 0. , 0. ],
+        [0. , 0. , 1. , 0. ],
+        [0. , 0. , 0. , 1. ]],
+       [[1. , 0. , 0. , 0.1],
+        [0. , 1. , 0. , 0. ],
+        [0. , 0. , 1. , 0. ],
+        [0. , 0. , 0. , 1. ]],
+       [[1. , 0. , 0. , 0.2],
+        [0. , 1. , 0. , 0. ],
+        [0. , 0. , 1. , 0. ],
+        [0. , 0. , 0. , 1. ]]])
+
+>>> m = pyrender.Mesh.from_trimesh(tm, poses=tfs)
+
+Custom Materials
+~~~~~~~~~~~~~~~~
+
+You can also specify a custom material for any triangular mesh you create
+in the ``material`` parameter of :meth:`.Mesh.from_trimesh`.
+The main material supported by Pyrender is the
+:class:`.MetallicRoughnessMaterial`.
+The metallic-roughness model supports rendering highly-realistic objects across
+a wide gamut of materials.
+
+For more information, see the documentation of the
+:class:`.MetallicRoughnessMaterial` constructor or look at the Khronos_
+documentation for more information.
+
+.. _Khronos: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#materials
+
+Creating Point Clouds
+---------------------
+
+Point Sprites
+~~~~~~~~~~~~~
+Pyrender also allows you to create a :class:`.Mesh` containing a
+point cloud directly from :class:`numpy.ndarray` instances
+using the :meth:`.Mesh.from_points` static method.
+
+Simply provide a list of points and optional per-point colors and normals.
+
+>>> pts = tm.vertices.copy()
+>>> colors = np.random.uniform(size=pts.shape)
+>>> m = pyrender.Mesh.from_points(pts, colors=colors)
+
+Point clouds created in this way will be rendered as square point sprites.
+
+.. image:: /_static/points.png
+
+Point Spheres
+~~~~~~~~~~~~~
+If you have a monochromatic point cloud and would like to render it with
+spheres, you can render it by instancing a spherical trimesh:
+
+>>> sm = trimesh.creation.uv_sphere(radius=0.1)
+>>> sm.visual.vertex_colors = [1.0, 0.0, 0.0]
+>>> tfs = np.tile(np.eye(4), (len(pts), 1, 1))
+>>> tfs[:,:3,3] = pts
+>>> m = pyrender.Mesh.from_trimesh(sm, poses=tfs)
+
+.. image:: /_static/points2.png

pyrender/docs/source/examples/offscreen.rst

@@ -0,0 +1,87 @@
+.. _offscreen_guide:
+
+Offscreen Rendering
+===================
+
+.. note::
+   If you're using a headless server, you'll need to use either EGL (for
+   GPU-accelerated rendering) or OSMesa (for CPU-only software rendering).
+   If you're using OSMesa, be sure that you've installed it properly. See
+   :ref:`osmesa` for details.
+
+Choosing a Backend
+------------------
+
+Once you have a scene set up with its geometry, cameras, and lights,
+you can render it using the :class:`.OffscreenRenderer`. Pyrender supports
+three backends for offscreen rendering:
+
+- Pyglet, the same engine that runs the viewer. This requires an active
+  display manager, so you can't run it on a headless server. This is the
+  default option.
+- OSMesa, a software renderer.
+- EGL, which allows for GPU-accelerated rendering without a display manager.
+
+If you want to use OSMesa or EGL, you need to set the ``PYOPENGL_PLATFORM``
+environment variable before importing pyrender or any other OpenGL library.
+You can do this at the command line:
+
+.. code-block:: bash
+
+   PYOPENGL_PLATFORM=osmesa python render.py
+
+or at the top of your Python script:
+
+.. code-block:: bash
+
+   # Top of main python script
+   import os
+   os.environ['PYOPENGL_PLATFORM'] = 'egl'
+
+The handle for EGL is ``egl``, and the handle for OSMesa is ``osmesa``.
+
+Running the Renderer
+--------------------
+
+Once you've set your environment variable appropriately, create your scene and
+then configure the :class:`.OffscreenRenderer` object with a window width,
+a window height, and a size for point-cloud points:
+
+>>> r = pyrender.OffscreenRenderer(viewport_width=640,
+...                                viewport_height=480,
+...                                point_size=1.0)
+
+Then, just call the :meth:`.OffscreenRenderer.render` function:
+
+>>> color, depth = r.render(scene)
+
+.. image:: /_static/scene.png
+
+This will return a ``(w,h,3)`` channel floating-point color image and
+a ``(w,h)`` floating-point depth image rendered from the scene's main camera.
+
+You can customize the rendering process by using flag options from
+:class:`.RenderFlags` and bitwise or-ing them together. For example,
+the following code renders a color image with an alpha channel
+and enables shadow mapping for all directional lights:
+
+>>> flags = RenderFlags.RGBA | RenderFlags.SHADOWS_DIRECTIONAL
+>>> color, depth = r.render(scene, flags=flags)
+
+Once you're done with the offscreen renderer, you need to close it before you
+can run a different renderer or open the viewer for the same scene:
+
+>>> r.delete()
+
+Google CoLab Examples
+---------------------
+
+For a minimal working example of offscreen rendering using OSMesa,
+see the `OSMesa Google CoLab notebook`_.
+
+.. _OSMesa Google CoLab notebook: https://colab.research.google.com/drive/1Z71mHIc-Sqval92nK290vAsHZRUkCjUx
+
+For a minimal working example of offscreen rendering using EGL,
+see the `EGL Google CoLab notebook`_.
+
+.. _EGL Google CoLab notebook: https://colab.research.google.com/drive/1rTLHk0qxh4dn8KNe-mCnN8HAWdd2_BEh

pyrender/docs/source/examples/quickstart.rst

@@ -0,0 +1,71 @@
+.. _quickstart_guide:
+
+Quickstart
+==========
+
+
+Minimal Example for 3D Viewer
+-----------------------------
+Here is a minimal example of loading and viewing a triangular mesh model
+in pyrender.
+
+>>> import trimesh
+>>> import pyrender
+>>> fuze_trimesh = trimesh.load('examples/models/fuze.obj')
+>>> mesh = pyrender.Mesh.from_trimesh(fuze_trimesh)
+>>> scene = pyrender.Scene()
+>>> scene.add(mesh)
+>>> pyrender.Viewer(scene, use_raymond_lighting=True)
+
+.. image:: /_static/fuze.png
+
+
+Minimal Example for Offscreen Rendering
+---------------------------------------
+.. note::
+   If you're using a headless server, make sure that you followed the guide
+   for installing OSMesa. See :ref:`osmesa`.
+
+Here is a minimal example of rendering a mesh model offscreen in pyrender.
+The only additional necessities are that you need to add lighting and a camera.
+
+>>> import numpy as np
+>>> import trimesh
+>>> import pyrender
+>>> import matplotlib.pyplot as plt
+
+>>> fuze_trimesh = trimesh.load('examples/models/fuze.obj')
+>>> mesh = pyrender.Mesh.from_trimesh(fuze_trimesh)
+>>> scene = pyrender.Scene()
+>>> scene.add(mesh)
+>>> camera = pyrender.PerspectiveCamera(yfov=np.pi / 3.0, aspectRatio=1.0)
+>>> s = np.sqrt(2)/2
+>>> camera_pose = np.array([
+...    [0.0, -s,   s,   0.3],
+...    [1.0,  0.0, 0.0, 0.0],
+...    [0.0,  s,   s,   0.35],
+...    [0.0,  0.0, 0.0, 1.0],
+... ])
+>>> scene.add(camera, pose=camera_pose)
+>>> light = pyrender.SpotLight(color=np.ones(3), intensity=3.0,
+...                            innerConeAngle=np.pi/16.0,
+...                            outerConeAngle=np.pi/6.0)
+>>> scene.add(light, pose=camera_pose)
+>>> r = pyrender.OffscreenRenderer(400, 400)
+>>> color, depth = r.render(scene)
+>>> plt.figure()
+>>> plt.subplot(1,2,1)
+>>> plt.axis('off')
+>>> plt.imshow(color)
+>>> plt.subplot(1,2,2)
+>>> plt.axis('off')
+>>> plt.imshow(depth, cmap=plt.cm.gray_r)
+>>> plt.show()
+
+.. image:: /_static/minexcolor.png
+   :width: 45%
+   :align: left
+.. image:: /_static/minexdepth.png
+   :width: 45%
+   :align: right
+

pyrender/docs/source/examples/scenes.rst

@@ -0,0 +1,78 @@
+.. _scene_guide:
+
+Creating Scenes
+===============
+
+Before you render anything, you need to put all of your lights, cameras,
+and meshes into a scene. The :class:`.Scene` object keeps track of the relative
+poses of these primitives by inserting them into :class:`.Node` objects and
+keeping them in a directed acyclic graph.
+
+Adding Objects
+--------------
+
+To create a :class:`.Scene`, simply call the constructor. You can optionally
+specify an ambient light color and a background color:
+
+>>> scene = pyrender.Scene(ambient_light=[0.02, 0.02, 0.02],
+...                        bg_color=[1.0, 1.0, 1.0])
+
+You can add objects to a scene by first creating a :class:`.Node` object
+and adding the object and its pose to the :class:`.Node`. Poses are specified
+as 4x4 homogenous transformation matrices that are stored in the node's
+:attr:`.Node.matrix` attribute. Note that the :class:`.Node`
+constructor requires you to specify whether you're adding a mesh, light,
+or camera.
+
+>>> mesh = pyrender.Mesh.from_trimesh(tm)
+>>> light = pyrender.PointLight(color=[1.0, 1.0, 1.0], intensity=2.0)
+>>> cam = pyrender.PerspectiveCamera(yfov=np.pi / 3.0, aspectRatio=1.414)
+>>> nm = pyrender.Node(mesh=mesh, matrix=np.eye(4))
+>>> nl = pyrender.Node(light=light, matrix=np.eye(4))
+>>> nc = pyrender.Node(camera=cam, matrix=np.eye(4))
+>>> scene.add_node(nm)
+>>> scene.add_node(nl)
+>>> scene.add_node(nc)
+
+You can also add objects directly to a scene with the :meth:`.Scene.add` function,
+which takes care of creating a :class:`.Node` for you.
+
+>>> scene.add(mesh, pose=np.eye(4))
+>>> scene.add(light, pose=np.eye(4))
+>>> scene.add(cam, pose=np.eye(4))
+
+Nodes can be hierarchical, in which case the node's :attr:`.Node.matrix`
+specifies that node's pose relative to its parent frame. You can add nodes to
+a scene hierarchically by specifying a parent node in your calls to
+:meth:`.Scene.add` or :meth:`.Scene.add_node`:
+
+>>> scene.add_node(nl, parent_node=nc)
+>>> scene.add(cam, parent_node=nm)
+
+If you add multiple cameras to a scene, you can specify which one to render from
+by setting the :attr:`.Scene.main_camera_node` attribute.
+
+Updating Objects
+----------------
+
+You can update the poses of existing nodes with the :meth:`.Scene.set_pose`
+function. Simply call it with a :class:`.Node` that is already in the scene
+and the new pose of that node with respect to its parent as a 4x4 homogenous
+transformation matrix:
+
+>>> scene.set_pose(nl, pose=np.eye(4))
+
+If you want to get the local pose of a node, you can just access its
+:attr:`.Node.matrix` attribute. However, if you want to the get
+the pose of a node *with respect to the world frame*, you can call the
+:meth:`.Scene.get_pose` method.
+
+>>> tf = scene.get_pose(nl)
+
+Removing Objects
+----------------
+
+Finally, you can remove a :class:`.Node` and all of its children from the
+scene with the :meth:`.Scene.remove_node` function:
+
+>>> scene.remove_node(nl)

pyrender/docs/source/examples/viewer.rst

@@ -0,0 +1,61 @@
+.. _viewer_guide:
+
+Live Scene Viewer
+=================
+
+Standard Usage
+--------------
+In addition to the offscreen renderer, Pyrender comes with a live scene viewer.
+In its standard invocation, calling the :class:`.Viewer`'s constructor will
+immediately pop a viewing window that you can navigate around in.
+
+>>> pyrender.Viewer(scene)
+
+By default, the viewer uses your scene's lighting. If you'd like to start with
+some additional lighting that moves around with the camera, you can specify that
+with:
+
+>>> pyrender.Viewer(scene, use_raymond_lighting=True)
+
+For a full list of the many options that the :class:`.Viewer` supports, check out its
+documentation.
+
+.. image:: /_static/rotation.gif
+
+Running the Viewer in a Separate Thread
+---------------------------------------
+If you'd like to animate your models, you'll want to run the viewer in a
+separate thread so that you can update the scene while the viewer is running.
+To do this, first pop the viewer in a separate thread by calling its constructor
+with the ``run_in_thread`` option set:
+
+>>> v = pyrender.Viewer(scene, run_in_thread=True)
+
+Then, you can manipulate the :class:`.Scene` while the viewer is running to
+animate things. However, be careful to acquire the viewer's
+:attr:`.Viewer.render_lock` before editing the scene to prevent data corruption:
+
+>>> i = 0
+>>> while True:
+...     pose = np.eye(4)
+...     pose[:3,3] = [i, 0, 0]
+...     v.render_lock.acquire()
+...     scene.set_pose(mesh_node, pose)
+...     v.render_lock.release()
+...     i += 0.01
+
+.. image:: /_static/scissors.gif
+
+You can wait on the viewer to be closed manually:
+
+>>> while v.is_active:
+...     pass
+
+Or you can close it from the main thread forcibly.
+Make sure to still loop and block for the viewer to actually exit before using
+the scene object again.
+
+>>> v.close_external()
+>>> while v.is_active:
+...     pass
+

pyrender/docs/source/index.rst

@@ -0,0 +1,41 @@
+.. core documentation master file, created by
+   sphinx-quickstart on Sun Oct 16 14:33:48 2016.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Pyrender Documentation
+========================
+Pyrender is a pure Python (2.7, 3.4, 3.5, 3.6) library for physically-based
+rendering and visualization.
+It is designed to meet the glTF 2.0 specification_ from Khronos
+
+.. _specification: https://www.khronos.org/gltf/
+
+Pyrender is lightweight, easy to install, and simple to use.
+It comes packaged with both an intuitive scene viewer and a headache-free
+offscreen renderer with support for GPU-accelerated rendering on headless
+servers, which makes it perfect for machine learning applications.
+Check out the :ref:`guide` for a full tutorial, or fork me on
+Github_.
+
+.. _Github: https://github.com/mmatl/pyrender
+
+.. image:: _static/rotation.gif
+
+.. image:: _static/damaged_helmet.png
+
+.. toctree::
+   :maxdepth: 2
+
+   install/index.rst
+   examples/index.rst
+   api/index.rst
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
+

pyrender/docs/source/install/index.rst

@@ -0,0 +1,172 @@
+Installation Guide
+==================
+
+Python Installation
+-------------------
+
+This package is available via ``pip``.
+
+.. code-block:: bash
+
+   pip install pyrender
+
+If you're on MacOS, you'll need
+to pre-install my fork of ``pyglet``, as the version on PyPI hasn't yet included
+my change that enables OpenGL contexts on MacOS.
+
+.. code-block:: bash
+
+   git clone https://github.com/mmatl/pyglet.git
+   cd pyglet
+   pip install .
+
+.. _osmesa:
+
+Getting Pyrender Working with OSMesa
+------------------------------------
+If you want to render scenes offscreen but don't want to have to
+install a display manager or deal with the pains of trying to get
+OpenGL to work over SSH, you have two options.
+
+The first (and preferred) option is using EGL, which enables you to perform
+GPU-accelerated rendering on headless servers.
+However, you'll need EGL 1.5 to get modern OpenGL contexts.
+This comes packaged with NVIDIA's current drivers, but if you are having issues
+getting EGL to work with your hardware, you can try using OSMesa,
+a software-based offscreen renderer that is included with any Mesa
+install.
+
+If you want to use OSMesa with pyrender, you'll have to perform two additional
+installation steps:
+
+- :ref:`installmesa`
+- :ref:`installpyopengl`
+
+Then, read the offscreen rendering tutorial. See :ref:`offscreen_guide`.
+
+.. _installmesa:
+
+Installing OSMesa
+*****************
+
+As a first step, you'll need to rebuild and re-install Mesa with support
+for fast offscreen rendering and OpenGL 3+ contexts.
+I'd recommend installing from source, but you can also try my ``.deb``
+for Ubuntu 16.04 and up.
+
+Installing from a Debian Package
+********************************
+
+If you're running Ubuntu 16.04 or newer, you should be able to install the
+required version of Mesa from my ``.deb`` file.
+
+.. code-block:: bash
+
+   sudo apt update
+   sudo wget https://github.com/mmatl/travis_debs/raw/master/xenial/mesa_18.3.3-0.deb
+   sudo dpkg -i ./mesa_18.3.3-0.deb || true
+   sudo apt install -f
+
+If this doesn't work, try building from source.
+
+Building From Source
+********************
+
+First, install build dependencies via `apt` or your system's package manager.
+
+.. code-block:: bash
+
+   sudo apt-get install llvm-6.0 freeglut3 freeglut3-dev
+
+Then, download the current release of Mesa from here_.
+Unpack the source and go to the source folder:
+
+.. _here: https://archive.mesa3d.org/mesa-18.3.3.tar.gz
+
+.. code-block:: bash
+
+   tar xfv mesa-18.3.3.tar.gz
+   cd mesa-18.3.3
+
+Replace ``PREFIX`` with the path you want to install Mesa at.
+If you're not worried about overwriting your default Mesa install,
+a good place is at ``/usr/local``.
+
+Now, configure the installation by running the following command:
+
+.. code-block:: bash
+
+   ./configure --prefix=PREFIX                                   \
+               --enable-opengl --disable-gles1 --disable-gles2   \
+               --disable-va --disable-xvmc --disable-vdpau       \
+               --enable-shared-glapi                             \
+               --disable-texture-float                           \
+               --enable-gallium-llvm --enable-llvm-shared-libs   \
+               --with-gallium-drivers=swrast,swr                 \
+               --disable-dri --with-dri-drivers=                 \
+               --disable-egl --with-egl-platforms= --disable-gbm \
+               --disable-glx                                     \
+               --disable-osmesa --enable-gallium-osmesa          \
+               ac_cv_path_LLVM_CONFIG=llvm-config-6.0
+
+Finally, build and install Mesa.
+
+.. code-block:: bash
+
+   make -j8
+   make install
+
+Finally, if you didn't install Mesa in the system path,
+add the following lines to your ``~/.bashrc`` file after
+changing ``MESA_HOME`` to your mesa installation path (i.e. what you used as
+``PREFIX`` during the configure command).
+
+.. code-block:: bash
+
+   MESA_HOME=/path/to/your/mesa/installation
+   export LIBRARY_PATH=$LIBRARY_PATH:$MESA_HOME/lib
+   export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$MESA_HOME/lib
+   export C_INCLUDE_PATH=$C_INCLUDE_PATH:$MESA_HOME/include/
+   export CPLUS_INCLUDE_PATH=$CPLUS_INCLUDE_PATH:$MESA_HOME/include/
+
+.. _installpyopengl:
+
+Installing a Compatible Fork of PyOpenGL
+****************************************
+
+Next, install and use my fork of ``PyOpenGL``.
+This fork enables getting modern OpenGL contexts with OSMesa.
+My patch has been included in ``PyOpenGL``, but it has not yet been released
+on PyPI.
+
+.. code-block:: bash
+
+   git clone https://github.com/mmatl/pyopengl.git
+   pip install ./pyopengl
+
+
+Building Documentation
+----------------------
+
+The online documentation for ``pyrender`` is automatically built by Read The Docs.
+Building ``pyrender``'s documentation locally requires a few extra dependencies --
+specifically, `sphinx`_ and a few plugins.
+
+.. _sphinx: http://www.sphinx-doc.org/en/master/
+
+To install the dependencies required, simply change directories into the `pyrender` source and run
+
+.. code-block:: bash
+
+    $ pip install .[docs]
+
+Then, go to the ``docs`` directory and run ``make`` with the appropriate target.
+For example,
+
+.. code-block:: bash
+
+    $ cd docs/
+    $ make html
+
+will generate a set of web pages. Any documentation files
+generated in this manner can be found in ``docs/build``.

pyrender/examples/duck.py

@@ -0,0 +1,13 @@
+from pyrender import Mesh, Scene, Viewer
+from io import BytesIO
+import numpy as np
+import trimesh
+import requests
+
+duck_source = "https://github.com/KhronosGroup/glTF-Sample-Models/raw/master/2.0/Duck/glTF-Binary/Duck.glb"
+
+duck = trimesh.load(BytesIO(requests.get(duck_source).content), file_type='glb')
+duckmesh = Mesh.from_trimesh(list(duck.geometry.values())[0])
+scene = Scene(ambient_light=np.array([1.0, 1.0, 1.0, 1.0]))
+scene.add(duckmesh)
+Viewer(scene)

pyrender/examples/example.py

@@ -0,0 +1,157 @@
+"""Examples of using pyrender for viewing and offscreen rendering.
+"""
+import pyglet
+pyglet.options['shadow_window'] = False
+import os
+import numpy as np
+import trimesh
+
+from pyrender import PerspectiveCamera,\
+                     DirectionalLight, SpotLight, PointLight,\
+                     MetallicRoughnessMaterial,\
+                     Primitive, Mesh, Node, Scene,\
+                     Viewer, OffscreenRenderer, RenderFlags
+
+#==============================================================================
+# Mesh creation
+#==============================================================================
+
+#------------------------------------------------------------------------------
+# Creating textured meshes from trimeshes
+#------------------------------------------------------------------------------
+
+# Fuze trimesh
+fuze_trimesh = trimesh.load('./models/fuze.obj')
+fuze_mesh = Mesh.from_trimesh(fuze_trimesh)
+
+# Drill trimesh
+drill_trimesh = trimesh.load('./models/drill.obj')
+drill_mesh = Mesh.from_trimesh(drill_trimesh)
+drill_pose = np.eye(4)
+drill_pose[0,3] = 0.1
+drill_pose[2,3] = -np.min(drill_trimesh.vertices[:,2])
+
+# Wood trimesh
+wood_trimesh = trimesh.load('./models/wood.obj')
+wood_mesh = Mesh.from_trimesh(wood_trimesh)
+
+# Water bottle trimesh
+bottle_gltf = trimesh.load('./models/WaterBottle.glb')
+bottle_trimesh = bottle_gltf.geometry[list(bottle_gltf.geometry.keys())[0]]
+bottle_mesh = Mesh.from_trimesh(bottle_trimesh)
+bottle_pose = np.array([
+    [1.0, 0.0,  0.0, 0.1],
+    [0.0, 0.0, -1.0, -0.16],
+    [0.0, 1.0,  0.0, 0.13],
+    [0.0, 0.0,  0.0, 1.0],
+])
+
+#------------------------------------------------------------------------------
+# Creating meshes with per-vertex colors
+#------------------------------------------------------------------------------
+boxv_trimesh = trimesh.creation.box(extents=0.1*np.ones(3))
+boxv_vertex_colors = np.random.uniform(size=(boxv_trimesh.vertices.shape))
+boxv_trimesh.visual.vertex_colors = boxv_vertex_colors
+boxv_mesh = Mesh.from_trimesh(boxv_trimesh, smooth=False)
+
+#------------------------------------------------------------------------------
+# Creating meshes with per-face colors
+#------------------------------------------------------------------------------
+boxf_trimesh = trimesh.creation.box(extents=0.1*np.ones(3))
+boxf_face_colors = np.random.uniform(size=boxf_trimesh.faces.shape)
+boxf_trimesh.visual.face_colors = boxf_face_colors
+boxf_mesh = Mesh.from_trimesh(boxf_trimesh, smooth=False)
+
+#------------------------------------------------------------------------------
+# Creating meshes from point clouds
+#------------------------------------------------------------------------------
+points = trimesh.creation.icosphere(radius=0.05).vertices
+point_colors = np.random.uniform(size=points.shape)
+points_mesh = Mesh.from_points(points, colors=point_colors)
+
+#==============================================================================
+# Light creation
+#==============================================================================
+
+direc_l = DirectionalLight(color=np.ones(3), intensity=1.0)
+spot_l = SpotLight(color=np.ones(3), intensity=10.0,
+                   innerConeAngle=np.pi/16, outerConeAngle=np.pi/6)
+point_l = PointLight(color=np.ones(3), intensity=10.0)
+
+#==============================================================================
+# Camera creation
+#==============================================================================
+
+cam = PerspectiveCamera(yfov=(np.pi / 3.0))
+cam_pose = np.array([
+    [0.0,  -np.sqrt(2)/2, np.sqrt(2)/2, 0.5],
+    [1.0, 0.0,           0.0,           0.0],
+    [0.0,  np.sqrt(2)/2,  np.sqrt(2)/2, 0.4],
+    [0.0,  0.0,           0.0,          1.0]
+])
+
+#==============================================================================
+# Scene creation
+#==============================================================================
+
+scene = Scene(ambient_light=np.array([0.02, 0.02, 0.02, 1.0]))
+
+#==============================================================================
+# Adding objects to the scene
+#==============================================================================
+
+#------------------------------------------------------------------------------
+# By manually creating nodes
+#------------------------------------------------------------------------------
+fuze_node = Node(mesh=fuze_mesh, translation=np.array([0.1, 0.15, -np.min(fuze_trimesh.vertices[:,2])]))
+scene.add_node(fuze_node)
+boxv_node = Node(mesh=boxv_mesh, translation=np.array([-0.1, 0.10, 0.05]))
+scene.add_node(boxv_node)
+boxf_node = Node(mesh=boxf_mesh, translation=np.array([-0.1, -0.10, 0.05]))
+scene.add_node(boxf_node)
+
+#------------------------------------------------------------------------------
+# By using the add() utility function
+#------------------------------------------------------------------------------
+drill_node = scene.add(drill_mesh, pose=drill_pose)
+bottle_node = scene.add(bottle_mesh, pose=bottle_pose)
+wood_node = scene.add(wood_mesh)
+direc_l_node = scene.add(direc_l, pose=cam_pose)
+spot_l_node = scene.add(spot_l, pose=cam_pose)
+
+#==============================================================================
+# Using the viewer with a default camera
+#==============================================================================
+
+v = Viewer(scene, shadows=True)
+
+#==============================================================================
+# Using the viewer with a pre-specified camera
+#==============================================================================
+cam_node = scene.add(cam, pose=cam_pose)
+v = Viewer(scene, central_node=drill_node)
+
+#==============================================================================
+# Rendering offscreen from that camera
+#==============================================================================
+
+r = OffscreenRenderer(viewport_width=640*2, viewport_height=480*2)
+color, depth = r.render(scene)
+
+import matplotlib.pyplot as plt
+plt.figure()
+plt.imshow(color)
+plt.show()
+
+#==============================================================================
+# Segmask rendering
+#==============================================================================
+
+nm = {node: 20*(i + 1) for i, node in enumerate(scene.mesh_nodes)}
+seg = r.render(scene, RenderFlags.SEG, nm)[0]
+plt.figure()
+plt.imshow(seg)
+plt.show()
+
+r.delete()
+

pyrender/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/pyrender/camera.py

@@ -0,0 +1,437 @@
+"""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 six
+import sys
+
+from .constants import DEFAULT_Z_NEAR, DEFAULT_Z_FAR
+
+
+@six.add_metaclass(abc.ABCMeta)
+class Camera(object):
+    """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/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']

pyrender/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/pyrender/light.py

@@ -0,0 +1,385 @@
+"""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
+import six
+
+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
+
+
+
+@six.add_metaclass(abc.ABCMeta)
+class Light(object):
+    """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']

pyrender/pyrender/material.py

@@ -0,0 +1,707 @@
+"""Material properties, conforming to the glTF 2.0 standards as specified in
+https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-material
+and
+https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness
+
+Author: Matthew Matl
+"""
+import abc
+import numpy as np
+import six
+
+from .constants import TexFlags
+from .utils import format_color_vector, format_texture_source
+from .texture import Texture
+
+
+@six.add_metaclass(abc.ABCMeta)
+class Material(object):
+    """Base for standard glTF 2.0 materials.
+
+    Parameters
+    ----------
+    name : str, optional
+        The user-defined name of this object.
+    normalTexture : (n,n,3) float or :class:`Texture`, optional
+        A tangent space normal map. The texture contains RGB components in
+        linear space. Each texel represents the XYZ components of a normal
+        vector in tangent space. Red [0 to 255] maps to X [-1 to 1]. Green
+        [0 to 255] maps to Y [-1 to 1]. Blue [128 to 255] maps to Z
+        [1/255 to 1]. The normal vectors use OpenGL conventions where +X is
+        right and +Y is up. +Z points toward the viewer.
+    occlusionTexture : (n,n,1) float or :class:`Texture`, optional
+        The occlusion map texture. The occlusion values are sampled from the R
+        channel. Higher values indicate areas that should receive full indirect
+        lighting and lower values indicate no indirect lighting. These values
+        are linear. If other channels are present (GBA), they are ignored for
+        occlusion calculations.
+    emissiveTexture : (n,n,3) float or :class:`Texture`, optional
+        The emissive map controls the color and intensity of the light being
+        emitted by the material. This texture contains RGB components in sRGB
+        color space. If a fourth component (A) is present, it is ignored.
+    emissiveFactor : (3,) float, optional
+        The RGB components of the emissive color of the material. These values
+        are linear. If an emissiveTexture is specified, this value is
+        multiplied with the texel values.
+    alphaMode : str, optional
+        The material's alpha rendering mode enumeration specifying the
+        interpretation of the alpha value of the main factor and texture.
+        Allowed Values:
+
+        - `"OPAQUE"` The alpha value is ignored and the rendered output is
+          fully opaque.
+        - `"MASK"` The rendered output is either fully opaque or fully
+          transparent depending on the alpha value and the specified alpha
+          cutoff value.
+        - `"BLEND"` The alpha value is used to composite the source and
+          destination areas. The rendered output is combined with the
+          background using the normal painting operation (i.e. the Porter
+          and Duff over operator).
+
+    alphaCutoff : float, optional
+        Specifies the cutoff threshold when in MASK mode. If the alpha value is
+        greater than or equal to this value then it is rendered as fully
+        opaque, otherwise, it is rendered as fully transparent.
+        A value greater than 1.0 will render the entire material as fully
+        transparent. This value is ignored for other modes.
+    doubleSided : bool, optional
+        Specifies whether the material is double sided. When this value is
+        false, back-face culling is enabled. When this value is true,
+        back-face culling is disabled and double sided lighting is enabled.
+    smooth : bool, optional
+        If True, the material is rendered smoothly by using only one normal
+        per vertex and face indexing.
+    wireframe : bool, optional
+        If True, the material is rendered in wireframe mode.
+    """
+
+    def __init__(self,
+                 name=None,
+                 normalTexture=None,
+                 occlusionTexture=None,
+                 emissiveTexture=None,
+                 emissiveFactor=None,
+                 alphaMode=None,
+                 alphaCutoff=None,
+                 doubleSided=False,
+                 smooth=True,
+                 wireframe=False):
+
+        # Set defaults
+        if alphaMode is None:
+            alphaMode = 'OPAQUE'
+
+        if alphaCutoff is None:
+            alphaCutoff = 0.5
+
+        if emissiveFactor is None:
+            emissiveFactor = np.zeros(3).astype(np.float32)
+
+        self.name = name
+        self.normalTexture = normalTexture
+        self.occlusionTexture = occlusionTexture
+        self.emissiveTexture = emissiveTexture
+        self.emissiveFactor = emissiveFactor
+        self.alphaMode = alphaMode
+        self.alphaCutoff = alphaCutoff
+        self.doubleSided = doubleSided
+        self.smooth = smooth
+        self.wireframe = wireframe
+
+        self._tex_flags = 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 normalTexture(self):
+        """(n,n,3) float or :class:`Texture` : The tangent-space normal map.
+        """
+        return self._normalTexture
+
+    @normalTexture.setter
+    def normalTexture(self, value):
+        # TODO TMP
+        self._normalTexture = self._format_texture(value, 'RGB')
+        self._tex_flags = None
+
+    @property
+    def occlusionTexture(self):
+        """(n,n,1) float or :class:`Texture` : The ambient occlusion map.
+        """
+        return self._occlusionTexture
+
+    @occlusionTexture.setter
+    def occlusionTexture(self, value):
+        self._occlusionTexture = self._format_texture(value, 'R')
+        self._tex_flags = None
+
+    @property
+    def emissiveTexture(self):
+        """(n,n,3) float or :class:`Texture` : The emission map.
+        """
+        return self._emissiveTexture
+
+    @emissiveTexture.setter
+    def emissiveTexture(self, value):
+        self._emissiveTexture = self._format_texture(value, 'RGB')
+        self._tex_flags = None
+
+    @property
+    def emissiveFactor(self):
+        """(3,) float : Base multiplier for emission colors.
+        """
+        return self._emissiveFactor
+
+    @emissiveFactor.setter
+    def emissiveFactor(self, value):
+        if value is None:
+            value = np.zeros(3)
+        self._emissiveFactor = format_color_vector(value, 3)
+
+    @property
+    def alphaMode(self):
+        """str : The mode for blending.
+        """
+        return self._alphaMode
+
+    @alphaMode.setter
+    def alphaMode(self, value):
+        if value not in set(['OPAQUE', 'MASK', 'BLEND']):
+            raise ValueError('Invalid alpha mode {}'.format(value))
+        self._alphaMode = value
+
+    @property
+    def alphaCutoff(self):
+        """float : The cutoff threshold in MASK mode.
+        """
+        return self._alphaCutoff
+
+    @alphaCutoff.setter
+    def alphaCutoff(self, value):
+        if value < 0 or value > 1:
+            raise ValueError('Alpha cutoff must be in range [0,1]')
+        self._alphaCutoff = float(value)
+
+    @property
+    def doubleSided(self):
+        """bool : Whether the material is double-sided.
+        """
+        return self._doubleSided
+
+    @doubleSided.setter
+    def doubleSided(self, value):
+        if not isinstance(value, bool):
+            raise TypeError('Double sided must be a boolean value')
+        self._doubleSided = value
+
+    @property
+    def smooth(self):
+        """bool : Whether to render the mesh smoothly by
+        interpolating vertex normals.
+        """
+        return self._smooth
+
+    @smooth.setter
+    def smooth(self, value):
+        if not isinstance(value, bool):
+            raise TypeError('Double sided must be a boolean value')
+        self._smooth = value
+
+    @property
+    def wireframe(self):
+        """bool : Whether to render the mesh in wireframe mode.
+        """
+        return self._wireframe
+
+    @wireframe.setter
+    def wireframe(self, value):
+        if not isinstance(value, bool):
+            raise TypeError('Wireframe must be a boolean value')
+        self._wireframe = value
+
+    @property
+    def is_transparent(self):
+        """bool : If True, the object is partially transparent.
+        """
+        return self._compute_transparency()
+
+    @property
+    def tex_flags(self):
+        """int : Texture availability flags.
+        """
+        if self._tex_flags is None:
+            self._tex_flags = self._compute_tex_flags()
+        return self._tex_flags
+
+    @property
+    def textures(self):
+        """list of :class:`Texture` : The textures associated with this
+        material.
+        """
+        return self._compute_textures()
+
+    def _compute_transparency(self):
+        return False
+
+    def _compute_tex_flags(self):
+        tex_flags = TexFlags.NONE
+        if self.normalTexture is not None:
+            tex_flags |= TexFlags.NORMAL
+        if self.occlusionTexture is not None:
+            tex_flags |= TexFlags.OCCLUSION
+        if self.emissiveTexture is not None:
+            tex_flags |= TexFlags.EMISSIVE
+        return tex_flags
+
+    def _compute_textures(self):
+        all_textures = [
+            self.normalTexture, self.occlusionTexture, self.emissiveTexture
+        ]
+        textures = set([t for t in all_textures if t is not None])
+        return textures
+
+    def _format_texture(self, texture, target_channels='RGB'):
+        """Format a texture as a float32 np array.
+        """
+        if isinstance(texture, Texture) or texture is None:
+            return texture
+        else:
+            source = format_texture_source(texture, target_channels)
+            return Texture(source=source, source_channels=target_channels)
+
+
+class MetallicRoughnessMaterial(Material):
+    """A material based on the metallic-roughness material model from
+    Physically-Based Rendering (PBR) methodology.
+
+    Parameters
+    ----------
+    name : str, optional
+        The user-defined name of this object.
+    normalTexture : (n,n,3) float or :class:`Texture`, optional
+        A tangent space normal map. The texture contains RGB components in
+        linear space. Each texel represents the XYZ components of a normal
+        vector in tangent space. Red [0 to 255] maps to X [-1 to 1]. Green
+        [0 to 255] maps to Y [-1 to 1]. Blue [128 to 255] maps to Z
+        [1/255 to 1]. The normal vectors use OpenGL conventions where +X is
+        right and +Y is up. +Z points toward the viewer.
+    occlusionTexture : (n,n,1) float or :class:`Texture`, optional
+        The occlusion map texture. The occlusion values are sampled from the R
+        channel. Higher values indicate areas that should receive full indirect
+        lighting and lower values indicate no indirect lighting. These values
+        are linear. If other channels are present (GBA), they are ignored for
+        occlusion calculations.
+    emissiveTexture : (n,n,3) float or :class:`Texture`, optional
+        The emissive map controls the color and intensity of the light being
+        emitted by the material. This texture contains RGB components in sRGB
+        color space. If a fourth component (A) is present, it is ignored.
+    emissiveFactor : (3,) float, optional
+        The RGB components of the emissive color of the material. These values
+        are linear. If an emissiveTexture is specified, this value is
+        multiplied with the texel values.
+    alphaMode : str, optional
+        The material's alpha rendering mode enumeration specifying the
+        interpretation of the alpha value of the main factor and texture.
+        Allowed Values:
+
+        - `"OPAQUE"` The alpha value is ignored and the rendered output is
+          fully opaque.
+        - `"MASK"` The rendered output is either fully opaque or fully
+          transparent depending on the alpha value and the specified alpha
+          cutoff value.
+        - `"BLEND"` The alpha value is used to composite the source and
+          destination areas. The rendered output is combined with the
+          background using the normal painting operation (i.e. the Porter
+          and Duff over operator).
+
+    alphaCutoff : float, optional
+        Specifies the cutoff threshold when in MASK mode. If the alpha value is
+        greater than or equal to this value then it is rendered as fully
+        opaque, otherwise, it is rendered as fully transparent.
+        A value greater than 1.0 will render the entire material as fully
+        transparent. This value is ignored for other modes.
+    doubleSided : bool, optional
+        Specifies whether the material is double sided. When this value is
+        false, back-face culling is enabled. When this value is true,
+        back-face culling is disabled and double sided lighting is enabled.
+    smooth : bool, optional
+        If True, the material is rendered smoothly by using only one normal
+        per vertex and face indexing.
+    wireframe : bool, optional
+        If True, the material is rendered in wireframe mode.
+    baseColorFactor : (4,) float, optional
+        The RGBA components of the base color of the material. The fourth
+        component (A) is the alpha coverage of the material. The alphaMode
+        property specifies how alpha is interpreted. These values are linear.
+        If a baseColorTexture is specified, this value is multiplied with the
+        texel values.
+    baseColorTexture : (n,n,4) float or :class:`Texture`, optional
+        The base color texture. This texture contains RGB(A) components in sRGB
+        color space. The first three components (RGB) specify the base color of
+        the material. If the fourth component (A) is present, it represents the
+        alpha coverage of the material. Otherwise, an alpha of 1.0 is assumed.
+        The alphaMode property specifies how alpha is interpreted.
+        The stored texels must not be premultiplied.
+    metallicFactor : float
+        The metalness of the material. A value of 1.0 means the material is a
+        metal. A value of 0.0 means the material is a dielectric. Values in
+        between are for blending between metals and dielectrics such as dirty
+        metallic surfaces. This value is linear. If a metallicRoughnessTexture
+        is specified, this value is multiplied with the metallic texel values.
+    roughnessFactor : float
+        The roughness of the material. A value of 1.0 means the material is
+        completely rough. A value of 0.0 means the material is completely
+        smooth. This value is linear. If a metallicRoughnessTexture is
+        specified, this value is multiplied with the roughness texel values.
+    metallicRoughnessTexture : (n,n,2) float or :class:`Texture`, optional
+        The metallic-roughness texture. The metalness values are sampled from
+        the B channel. The roughness values are sampled from the G channel.
+        These values are linear. If other channels are present (R or A), they
+        are ignored for metallic-roughness calculations.
+    """
+
+    def __init__(self,
+                 name=None,
+                 normalTexture=None,
+                 occlusionTexture=None,
+                 emissiveTexture=None,
+                 emissiveFactor=None,
+                 alphaMode=None,
+                 alphaCutoff=None,
+                 doubleSided=False,
+                 smooth=True,
+                 wireframe=False,
+                 baseColorFactor=None,
+                 baseColorTexture=None,
+                 metallicFactor=1.0,
+                 roughnessFactor=1.0,
+                 metallicRoughnessTexture=None):
+        super(MetallicRoughnessMaterial, self).__init__(
+            name=name,
+            normalTexture=normalTexture,
+            occlusionTexture=occlusionTexture,
+            emissiveTexture=emissiveTexture,
+            emissiveFactor=emissiveFactor,
+            alphaMode=alphaMode,
+            alphaCutoff=alphaCutoff,
+            doubleSided=doubleSided,
+            smooth=smooth,
+            wireframe=wireframe
+        )
+
+        # Set defaults
+        if baseColorFactor is None:
+            baseColorFactor = np.ones(4).astype(np.float32)
+
+        self.baseColorFactor = baseColorFactor
+        self.baseColorTexture = baseColorTexture
+        self.metallicFactor = metallicFactor
+        self.roughnessFactor = roughnessFactor
+        self.metallicRoughnessTexture = metallicRoughnessTexture
+
+    @property
+    def baseColorFactor(self):
+        """(4,) float or :class:`Texture` : The RGBA base color multiplier.
+        """
+        return self._baseColorFactor
+
+    @baseColorFactor.setter
+    def baseColorFactor(self, value):
+        if value is None:
+            value = np.ones(4)
+        self._baseColorFactor = format_color_vector(value, 4)
+
+    @property
+    def baseColorTexture(self):
+        """(n,n,4) float or :class:`Texture` : The diffuse texture.
+        """
+        return self._baseColorTexture
+
+    @baseColorTexture.setter
+    def baseColorTexture(self, value):
+        self._baseColorTexture = self._format_texture(value, 'RGBA')
+        self._tex_flags = None
+
+    @property
+    def metallicFactor(self):
+        """float : The metalness of the material.
+        """
+        return self._metallicFactor
+
+    @metallicFactor.setter
+    def metallicFactor(self, value):
+        if value is None:
+            value = 1.0
+        if value < 0 or value > 1:
+            raise ValueError('Metallic factor must be in range [0,1]')
+        self._metallicFactor = float(value)
+
+    @property
+    def roughnessFactor(self):
+        """float : The roughness of the material.
+        """
+        return self.RoughnessFactor
+
+    @roughnessFactor.setter
+    def roughnessFactor(self, value):
+        if value is None:
+            value = 1.0
+        if value < 0 or value > 1:
+            raise ValueError('Roughness factor must be in range [0,1]')
+        self.RoughnessFactor = float(value)
+
+    @property
+    def metallicRoughnessTexture(self):
+        """(n,n,2) float or :class:`Texture` : The metallic-roughness texture.
+        """
+        return self._metallicRoughnessTexture
+
+    @metallicRoughnessTexture.setter
+    def metallicRoughnessTexture(self, value):
+        self._metallicRoughnessTexture = self._format_texture(value, 'GB')
+        self._tex_flags = None
+
+    def _compute_tex_flags(self):
+        tex_flags = super(MetallicRoughnessMaterial, self)._compute_tex_flags()
+        if self.baseColorTexture is not None:
+            tex_flags |= TexFlags.BASE_COLOR
+        if self.metallicRoughnessTexture is not None:
+            tex_flags |= TexFlags.METALLIC_ROUGHNESS
+        return tex_flags
+
+    def _compute_transparency(self):
+        if self.alphaMode == 'OPAQUE':
+            return False
+        cutoff = self.alphaCutoff
+        if self.alphaMode == 'BLEND':
+            cutoff = 1.0
+        if self.baseColorFactor[3] < cutoff:
+            return True
+        if (self.baseColorTexture is not None and
+                self.baseColorTexture.is_transparent(cutoff)):
+            return True
+        return False
+
+    def _compute_textures(self):
+        textures = super(MetallicRoughnessMaterial, self)._compute_textures()
+        all_textures = [self.baseColorTexture, self.metallicRoughnessTexture]
+        all_textures = {t for t in all_textures if t is not None}
+        textures |= all_textures
+        return textures
+
+
+class SpecularGlossinessMaterial(Material):
+    """A material based on the specular-glossiness material model from
+    Physically-Based Rendering (PBR) methodology.
+
+    Parameters
+    ----------
+    name : str, optional
+        The user-defined name of this object.
+    normalTexture : (n,n,3) float or :class:`Texture`, optional
+        A tangent space normal map. The texture contains RGB components in
+        linear space. Each texel represents the XYZ components of a normal
+        vector in tangent space. Red [0 to 255] maps to X [-1 to 1]. Green
+        [0 to 255] maps to Y [-1 to 1]. Blue [128 to 255] maps to Z
+        [1/255 to 1]. The normal vectors use OpenGL conventions where +X is
+        right and +Y is up. +Z points toward the viewer.
+    occlusionTexture : (n,n,1) float or :class:`Texture`, optional
+        The occlusion map texture. The occlusion values are sampled from the R
+        channel. Higher values indicate areas that should receive full indirect
+        lighting and lower values indicate no indirect lighting. These values
+        are linear. If other channels are present (GBA), they are ignored for
+        occlusion calculations.
+    emissiveTexture : (n,n,3) float or :class:`Texture`, optional
+        The emissive map controls the color and intensity of the light being
+        emitted by the material. This texture contains RGB components in sRGB
+        color space. If a fourth component (A) is present, it is ignored.
+    emissiveFactor : (3,) float, optional
+        The RGB components of the emissive color of the material. These values
+        are linear. If an emissiveTexture is specified, this value is
+        multiplied with the texel values.
+    alphaMode : str, optional
+        The material's alpha rendering mode enumeration specifying the
+        interpretation of the alpha value of the main factor and texture.
+        Allowed Values:
+
+        - `"OPAQUE"` The alpha value is ignored and the rendered output is
+          fully opaque.
+        - `"MASK"` The rendered output is either fully opaque or fully
+          transparent depending on the alpha value and the specified alpha
+          cutoff value.
+        - `"BLEND"` The alpha value is used to composite the source and
+          destination areas. The rendered output is combined with the
+          background using the normal painting operation (i.e. the Porter
+          and Duff over operator).
+
+    alphaCutoff : float, optional
+        Specifies the cutoff threshold when in MASK mode. If the alpha value is
+        greater than or equal to this value then it is rendered as fully
+        opaque, otherwise, it is rendered as fully transparent.
+        A value greater than 1.0 will render the entire material as fully
+        transparent. This value is ignored for other modes.
+    doubleSided : bool, optional
+        Specifies whether the material is double sided. When this value is
+        false, back-face culling is enabled. When this value is true,
+        back-face culling is disabled and double sided lighting is enabled.
+    smooth : bool, optional
+        If True, the material is rendered smoothly by using only one normal
+        per vertex and face indexing.
+    wireframe : bool, optional
+        If True, the material is rendered in wireframe mode.
+    diffuseFactor : (4,) float
+        The RGBA components of the reflected diffuse color of the material.
+        Metals have a diffuse value of [0.0, 0.0, 0.0]. The fourth component
+        (A) is the opacity of the material. The values are linear.
+    diffuseTexture : (n,n,4) float or :class:`Texture`, optional
+        The diffuse texture. This texture contains RGB(A) components of the
+        reflected diffuse color of the material in sRGB color space. If the
+        fourth component (A) is present, it represents the alpha coverage of
+        the material. Otherwise, an alpha of 1.0 is assumed.
+        The alphaMode property specifies how alpha is interpreted.
+        The stored texels must not be premultiplied.
+    specularFactor : (3,) float
+        The specular RGB color of the material. This value is linear.
+    glossinessFactor : float
+        The glossiness or smoothness of the material. A value of 1.0 means the
+        material has full glossiness or is perfectly smooth. A value of 0.0
+        means the material has no glossiness or is perfectly rough. This value
+        is linear.
+    specularGlossinessTexture : (n,n,4) or :class:`Texture`, optional
+        The specular-glossiness texture is a RGBA texture, containing the
+        specular color (RGB) in sRGB space and the glossiness value (A) in
+        linear space.
+    """
+
+    def __init__(self,
+                 name=None,
+                 normalTexture=None,
+                 occlusionTexture=None,
+                 emissiveTexture=None,
+                 emissiveFactor=None,
+                 alphaMode=None,
+                 alphaCutoff=None,
+                 doubleSided=False,
+                 smooth=True,
+                 wireframe=False,
+                 diffuseFactor=None,
+                 diffuseTexture=None,
+                 specularFactor=None,
+                 glossinessFactor=1.0,
+                 specularGlossinessTexture=None):
+        super(SpecularGlossinessMaterial, self).__init__(
+            name=name,
+            normalTexture=normalTexture,
+            occlusionTexture=occlusionTexture,
+            emissiveTexture=emissiveTexture,
+            emissiveFactor=emissiveFactor,
+            alphaMode=alphaMode,
+            alphaCutoff=alphaCutoff,
+            doubleSided=doubleSided,
+            smooth=smooth,
+            wireframe=wireframe
+        )
+
+        # Set defaults
+        if diffuseFactor is None:
+            diffuseFactor = np.ones(4).astype(np.float32)
+        if specularFactor is None:
+            specularFactor = np.ones(3).astype(np.float32)
+
+        self.diffuseFactor = diffuseFactor
+        self.diffuseTexture = diffuseTexture
+        self.specularFactor = specularFactor
+        self.glossinessFactor = glossinessFactor
+        self.specularGlossinessTexture = specularGlossinessTexture
+
+    @property
+    def diffuseFactor(self):
+        """(4,) float : The diffuse base color.
+        """
+        return self._diffuseFactor
+
+    @diffuseFactor.setter
+    def diffuseFactor(self, value):
+        self._diffuseFactor = format_color_vector(value, 4)
+
+    @property
+    def diffuseTexture(self):
+        """(n,n,4) float or :class:`Texture` : The diffuse map.
+        """
+        return self._diffuseTexture
+
+    @diffuseTexture.setter
+    def diffuseTexture(self, value):
+        self._diffuseTexture = self._format_texture(value, 'RGBA')
+        self._tex_flags = None
+
+    @property
+    def specularFactor(self):
+        """(3,) float : The specular color of the material.
+        """
+        return self._specularFactor
+
+    @specularFactor.setter
+    def specularFactor(self, value):
+        self._specularFactor = format_color_vector(value, 3)
+
+    @property
+    def glossinessFactor(self):
+        """float : The glossiness of the material.
+        """
+        return self.glossinessFactor
+
+    @glossinessFactor.setter
+    def glossinessFactor(self, value):
+        if value < 0 or value > 1:
+            raise ValueError('glossiness factor must be in range [0,1]')
+        self._glossinessFactor = float(value)
+
+    @property
+    def specularGlossinessTexture(self):
+        """(n,n,4) or :class:`Texture` : The specular-glossiness texture.
+        """
+        return self._specularGlossinessTexture
+
+    @specularGlossinessTexture.setter
+    def specularGlossinessTexture(self, value):
+        self._specularGlossinessTexture = self._format_texture(value, 'GB')
+        self._tex_flags = None
+
+    def _compute_tex_flags(self):
+        flags = super(SpecularGlossinessMaterial, self)._compute_tex_flags()
+        if self.diffuseTexture is not None:
+            flags |= TexFlags.DIFFUSE
+        if self.specularGlossinessTexture is not None:
+            flags |= TexFlags.SPECULAR_GLOSSINESS
+        return flags
+
+    def _compute_transparency(self):
+        if self.alphaMode == 'OPAQUE':
+            return False
+        cutoff = self.alphaCutoff
+        if self.alphaMode == 'BLEND':
+            cutoff = 1.0
+        if self.diffuseFactor[3] < cutoff:
+            return True
+        if (self.diffuseTexture is not None and
+                self.diffuseTexture.is_transparent(cutoff)):
+            return True
+        return False
+
+    def _compute_textures(self):
+        textures = super(SpecularGlossinessMaterial, self)._compute_textures()
+        all_textures = [self.diffuseTexture, self.specularGlossinessTexture]
+        all_textures = {t for t in all_textures if t is not None}
+        textures |= all_textures
+        return textures

pyrender/pyrender/mesh.py

@@ -0,0 +1,328 @@
+"""Meshes, conforming to the glTF 2.0 standards as specified in
+https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-mesh
+
+Author: Matthew Matl
+"""
+import copy
+
+import numpy as np
+import trimesh
+
+from .primitive import Primitive
+from .constants import GLTF
+from .material import MetallicRoughnessMaterial
+
+
+class Mesh(object):
+    """A set of primitives to be rendered.
+
+    Parameters
+    ----------
+    name : str
+        The user-defined name of this object.
+    primitives : list of :class:`Primitive`
+        The primitives associated with this mesh.
+    weights : (k,) float
+        Array of weights to be applied to the Morph Targets.
+    is_visible : bool
+        If False, the mesh will not be rendered.
+    """
+
+    def __init__(self, primitives, name=None, weights=None, is_visible=True):
+        self.primitives = primitives
+        self.name = name
+        self.weights = weights
+        self.is_visible = is_visible
+
+        self._bounds = 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 primitives(self):
+        """list of :class:`Primitive` : The primitives associated
+        with this mesh.
+        """
+        return self._primitives
+
+    @primitives.setter
+    def primitives(self, value):
+        self._primitives = value
+
+    @property
+    def weights(self):
+        """(k,) float : Weights to be applied to morph targets.
+        """
+        return self._weights
+
+    @weights.setter
+    def weights(self, value):
+        self._weights = value
+
+    @property
+    def is_visible(self):
+        """bool : Whether the mesh is visible.
+        """
+        return self._is_visible
+
+    @is_visible.setter
+    def is_visible(self, value):
+        self._is_visible = value
+
+    @property
+    def bounds(self):
+        """(2,3) float : The axis-aligned bounds of the mesh.
+        """
+        if self._bounds is None:
+            bounds = np.array([[np.infty, np.infty, np.infty],
+                               [-np.infty, -np.infty, -np.infty]])
+            for p in self.primitives:
+                bounds[0] = np.minimum(bounds[0], p.bounds[0])
+                bounds[1] = np.maximum(bounds[1], p.bounds[1])
+            self._bounds = bounds
+        return self._bounds
+
+    @property
+    def centroid(self):
+        """(3,) float : The centroid of the mesh's axis-aligned bounding box
+        (AABB).
+        """
+        return np.mean(self.bounds, axis=0)
+
+    @property
+    def extents(self):
+        """(3,) float : The lengths of the axes of the mesh's AABB.
+        """
+        return np.diff(self.bounds, axis=0).reshape(-1)
+
+    @property
+    def scale(self):
+        """(3,) float : The length of the diagonal of the mesh's AABB.
+        """
+        return np.linalg.norm(self.extents)
+
+    @property
+    def is_transparent(self):
+        """bool : If True, the mesh is partially-transparent.
+        """
+        for p in self.primitives:
+            if p.is_transparent:
+                return True
+        return False
+
+    @staticmethod
+    def from_points(points, colors=None, normals=None,
+                    is_visible=True, poses=None):
+        """Create a Mesh from a set of points.
+
+        Parameters
+        ----------
+        points : (n,3) float
+            The point positions.
+        colors : (n,3) or (n,4) float, optional
+            RGB or RGBA colors for each point.
+        normals : (n,3) float, optionals
+            The normal vectors for each point.
+        is_visible : bool
+            If False, the points will not be rendered.
+        poses : (x,4,4)
+            Array of 4x4 transformation matrices for instancing this object.
+
+        Returns
+        -------
+        mesh : :class:`Mesh`
+            The created mesh.
+        """
+        primitive = Primitive(
+            positions=points,
+            normals=normals,
+            color_0=colors,
+            mode=GLTF.POINTS,
+            poses=poses
+        )
+        mesh = Mesh(primitives=[primitive], is_visible=is_visible)
+        return mesh
+
+    @staticmethod
+    def from_trimesh(mesh, material=None, is_visible=True,
+                     poses=None, wireframe=False, smooth=True):
+        """Create a Mesh from a :class:`~trimesh.base.Trimesh`.
+
+        Parameters
+        ----------
+        mesh : :class:`~trimesh.base.Trimesh` or list of them
+            A triangular mesh or a list of meshes.
+        material : :class:`Material`
+            The material of the object. Overrides any mesh material.
+            If not specified and the mesh has no material, a default material
+            will be used.
+        is_visible : bool
+            If False, the mesh will not be rendered.
+        poses : (n,4,4) float
+            Array of 4x4 transformation matrices for instancing this object.
+        wireframe : bool
+            If `True`, the mesh will be rendered as a wireframe object
+        smooth : bool
+            If `True`, the mesh will be rendered with interpolated vertex
+            normals. Otherwise, the mesh edges will stay sharp.
+
+        Returns
+        -------
+        mesh : :class:`Mesh`
+            The created mesh.
+        """
+
+        if isinstance(mesh, (list, tuple, set, np.ndarray)):
+            meshes = list(mesh)
+        elif isinstance(mesh, trimesh.Trimesh):
+            meshes = [mesh]
+        else:
+            raise TypeError('Expected a Trimesh or a list, got a {}'
+                            .format(type(mesh)))
+
+        primitives = []
+        for m in meshes:
+            positions = None
+            normals = None
+            indices = None
+
+            # Compute positions, normals, and indices
+            if smooth:
+                positions = m.vertices.copy()
+                normals = m.vertex_normals.copy()
+                indices = m.faces.copy()
+            else:
+                positions = m.vertices[m.faces].reshape((3 * len(m.faces), 3))
+                normals = np.repeat(m.face_normals, 3, axis=0)
+
+            # Compute colors, texture coords, and material properties
+            color_0, texcoord_0, primitive_material = Mesh._get_trimesh_props(m, smooth=smooth, material=material)
+
+            # Override if material is given.
+            if material is not None:
+                #primitive_material = copy.copy(material)
+                primitive_material = copy.deepcopy(material)  # TODO
+
+            if primitive_material is None:
+                # Replace material with default if needed
+                primitive_material = MetallicRoughnessMaterial(
+                    alphaMode='BLEND',
+                    baseColorFactor=[0.3, 0.3, 0.3, 1.0],
+                    metallicFactor=0.2,
+                    roughnessFactor=0.8
+                )
+
+            primitive_material.wireframe = wireframe
+
+            # Create the primitive
+            primitives.append(Primitive(
+                positions=positions,
+                normals=normals,
+                texcoord_0=texcoord_0,
+                color_0=color_0,
+                indices=indices,
+                material=primitive_material,
+                mode=GLTF.TRIANGLES,
+                poses=poses
+            ))
+
+        return Mesh(primitives=primitives, is_visible=is_visible)
+
+    @staticmethod
+    def _get_trimesh_props(mesh, smooth=False, material=None):
+        """Gets the vertex colors, texture coordinates, and material properties
+        from a :class:`~trimesh.base.Trimesh`.
+        """
+        colors = None
+        texcoords = None
+
+        # If the trimesh visual is undefined, return none for both
+        if not mesh.visual.defined:
+            return colors, texcoords, material
+
+        # Process vertex colors
+        if material is None:
+            if mesh.visual.kind == 'vertex':
+                vc = mesh.visual.vertex_colors.copy()
+                if smooth:
+                    colors = vc
+                else:
+                    colors = vc[mesh.faces].reshape(
+                        (3 * len(mesh.faces), vc.shape[1])
+                    )
+                material = MetallicRoughnessMaterial(
+                    alphaMode='BLEND',
+                    baseColorFactor=[1.0, 1.0, 1.0, 1.0],
+                    metallicFactor=0.2,
+                    roughnessFactor=0.8
+                )
+            # Process face colors
+            elif mesh.visual.kind == 'face':
+                if smooth:
+                    raise ValueError('Cannot use face colors with a smooth mesh')
+                else:
+                    colors = np.repeat(mesh.visual.face_colors, 3, axis=0)
+
+                material = MetallicRoughnessMaterial(
+                    alphaMode='BLEND',
+                    baseColorFactor=[1.0, 1.0, 1.0, 1.0],
+                    metallicFactor=0.2,
+                    roughnessFactor=0.8
+                )
+
+        # Process texture colors
+        if mesh.visual.kind == 'texture':
+            # Configure UV coordinates
+            if mesh.visual.uv is not None and len(mesh.visual.uv) != 0:
+                uv = mesh.visual.uv.copy()
+                if smooth:
+                    texcoords = uv
+                else:
+                    texcoords = uv[mesh.faces].reshape(
+                        (3 * len(mesh.faces), uv.shape[1])
+                    )
+
+            if material is None:
+                # Configure mesh material
+                mat = mesh.visual.material
+
+                if isinstance(mat, trimesh.visual.texture.PBRMaterial):
+                    material = MetallicRoughnessMaterial(
+                        normalTexture=mat.normalTexture,
+                        occlusionTexture=mat.occlusionTexture,
+                        emissiveTexture=mat.emissiveTexture,
+                        emissiveFactor=mat.emissiveFactor,
+                        alphaMode='BLEND',
+                        baseColorFactor=mat.baseColorFactor,
+                        baseColorTexture=mat.baseColorTexture,
+                        metallicFactor=mat.metallicFactor,
+                        roughnessFactor=mat.roughnessFactor,
+                        metallicRoughnessTexture=mat.metallicRoughnessTexture,
+                        doubleSided=mat.doubleSided,
+                        alphaCutoff=mat.alphaCutoff
+                    )
+                elif isinstance(mat, trimesh.visual.texture.SimpleMaterial):
+                    glossiness = mat.kwargs.get('Ns', 1.0)
+                    if isinstance(glossiness, list):
+                        glossiness = float(glossiness[0])
+                    roughness = (2 / (glossiness + 2)) ** (1.0 / 4.0)
+                    material = MetallicRoughnessMaterial(
+                        alphaMode='BLEND',
+                        roughnessFactor=roughness,
+                        baseColorFactor=mat.diffuse,
+                        baseColorTexture=mat.image,
+                    )
+                elif isinstance(mat, MetallicRoughnessMaterial):
+                    material = mat
+
+        return colors, texcoords, material

pyrender/pyrender/node.py

@@ -0,0 +1,263 @@
+"""Nodes, conforming to the glTF 2.0 standards as specified in
+https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-node
+
+Author: Matthew Matl
+"""
+import numpy as np
+
+import trimesh.transformations as transformations
+
+from .camera import Camera
+from .mesh import Mesh
+from .light import Light
+
+
+class Node(object):
+    """A node in the node hierarchy.
+
+    Parameters
+    ----------
+    name : str, optional
+        The user-defined name of this object.
+    camera : :class:`Camera`, optional
+        The camera in this node.
+    children : list of :class:`Node`
+        The children of this node.
+    skin : int, optional
+        The index of the skin referenced by this node.
+    matrix : (4,4) float, optional
+        A floating-point 4x4 transformation matrix.
+    mesh : :class:`Mesh`, optional
+        The mesh in this node.
+    rotation : (4,) float, optional
+        The node's unit quaternion in the order (x, y, z, w), where
+        w is the scalar.
+    scale : (3,) float, optional
+        The node's non-uniform scale, given as the scaling factors along the x,
+        y, and z axes.
+    translation : (3,) float, optional
+        The node's translation along the x, y, and z axes.
+    weights : (n,) float
+        The weights of the instantiated Morph Target. Number of elements must
+        match number of Morph Targets of used mesh.
+    light : :class:`Light`, optional
+        The light in this node.
+    """
+
+    def __init__(self,
+                 name=None,
+                 camera=None,
+                 children=None,
+                 skin=None,
+                 matrix=None,
+                 mesh=None,
+                 rotation=None,
+                 scale=None,
+                 translation=None,
+                 weights=None,
+                 light=None):
+        # Set defaults
+        if children is None:
+            children = []
+
+        self._matrix = None
+        self._scale = None
+        self._rotation = None
+        self._translation = None
+        if matrix is None:
+            if rotation is None:
+                rotation = np.array([0.0, 0.0, 0.0, 1.0])
+            if translation is None:
+                translation = np.zeros(3)
+            if scale is None:
+                scale = np.ones(3)
+            self.rotation = rotation
+            self.translation = translation
+            self.scale = scale
+        else:
+            self.matrix = matrix
+
+        self.name = name
+        self.camera = camera
+        self.children = children
+        self.skin = skin
+        self.mesh = mesh
+        self.weights = weights
+        self.light = light
+
+    @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 camera(self):
+        """:class:`Camera` : The camera in this node.
+        """
+        return self._camera
+
+    @camera.setter
+    def camera(self, value):
+        if value is not None and not isinstance(value, Camera):
+            raise TypeError('Value must be a camera')
+        self._camera = value
+
+    @property
+    def children(self):
+        """list of :class:`Node` : The children of this node.
+        """
+        return self._children
+
+    @children.setter
+    def children(self, value):
+        self._children = value
+
+    @property
+    def skin(self):
+        """int : The skin index for this node.
+        """
+        return self._skin
+
+    @skin.setter
+    def skin(self, value):
+        self._skin = value
+
+    @property
+    def mesh(self):
+        """:class:`Mesh` : The mesh in this node.
+        """
+        return self._mesh
+
+    @mesh.setter
+    def mesh(self, value):
+        if value is not None and not isinstance(value, Mesh):
+            raise TypeError('Value must be a mesh')
+        self._mesh = value
+
+    @property
+    def light(self):
+        """:class:`Light` : The light in this node.
+        """
+        return self._light
+
+    @light.setter
+    def light(self, value):
+        if value is not None and not isinstance(value, Light):
+            raise TypeError('Value must be a light')
+        self._light = value
+
+    @property
+    def rotation(self):
+        """(4,) float : The xyzw quaternion for this node.
+        """
+        return self._rotation
+
+    @rotation.setter
+    def rotation(self, value):
+        value = np.asanyarray(value)
+        if value.shape != (4,):
+            raise ValueError('Quaternion must be a (4,) vector')
+        if np.abs(np.linalg.norm(value) - 1.0) > 1e-3:
+            raise ValueError('Quaternion must have norm == 1.0')
+        self._rotation = value
+        self._matrix = None
+
+    @property
+    def translation(self):
+        """(3,) float : The translation for this node.
+        """
+        return self._translation
+
+    @translation.setter
+    def translation(self, value):
+        value = np.asanyarray(value)
+        if value.shape != (3,):
+            raise ValueError('Translation must be a (3,) vector')
+        self._translation = value
+        self._matrix = None
+
+    @property
+    def scale(self):
+        """(3,) float : The scale for this node.
+        """
+        return self._scale
+
+    @scale.setter
+    def scale(self, value):
+        value = np.asanyarray(value)
+        if value.shape != (3,):
+            raise ValueError('Scale must be a (3,) vector')
+        self._scale = value
+        self._matrix = None
+
+    @property
+    def matrix(self):
+        """(4,4) float : The homogenous transform matrix for this node.
+
+        Note that this matrix's elements are not settable,
+        it's just a copy of the internal matrix. You can set the whole
+        matrix, but not an individual element.
+        """
+        if self._matrix is None:
+            self._matrix = self._m_from_tqs(
+                self.translation, self.rotation, self.scale
+            )
+        return self._matrix.copy()
+
+    @matrix.setter
+    def matrix(self, value):
+        value = np.asanyarray(value)
+        if value.shape != (4,4):
+            raise ValueError('Matrix must be a 4x4 numpy ndarray')
+        if not np.allclose(value[3,:], np.array([0.0, 0.0, 0.0, 1.0])):
+            raise ValueError('Bottom row of matrix must be [0,0,0,1]')
+        self.rotation = Node._q_from_m(value)
+        self.scale = Node._s_from_m(value)
+        self.translation = Node._t_from_m(value)
+        self._matrix = value
+
+    @staticmethod
+    def _t_from_m(m):
+        return m[:3,3]
+
+    @staticmethod
+    def _r_from_m(m):
+        U = m[:3,:3]
+        norms = np.linalg.norm(U.T, axis=1)
+        return U / norms
+
+    @staticmethod
+    def _q_from_m(m):
+        M = np.eye(4)
+        M[:3,:3] = Node._r_from_m(m)
+        q_wxyz = transformations.quaternion_from_matrix(M)
+        return np.roll(q_wxyz, -1)
+
+    @staticmethod
+    def _s_from_m(m):
+        return np.linalg.norm(m[:3,:3].T, axis=1)
+
+    @staticmethod
+    def _r_from_q(q):
+        q_wxyz = np.roll(q, 1)
+        return transformations.quaternion_matrix(q_wxyz)[:3,:3]
+
+    @staticmethod
+    def _m_from_tqs(t, q, s):
+        S = np.eye(4)
+        S[:3,:3] = np.diag(s)
+
+        R = np.eye(4)
+        R[:3,:3] = Node._r_from_q(q)
+
+        T = np.eye(4)
+        T[:3,3] = t
+
+        return T.dot(R.dot(S))

pyrender/pyrender/offscreen.py

@@ -0,0 +1,160 @@
+"""Wrapper for offscreen rendering.
+
+Author: Matthew Matl
+"""
+import os
+
+from .renderer import Renderer
+from .constants import RenderFlags
+
+
+class OffscreenRenderer(object):
+    """A wrapper for offscreen rendering.
+
+    Parameters
+    ----------
+    viewport_width : int
+        The width of the main viewport, in pixels.
+    viewport_height : int
+        The height of the main viewport, in pixels.
+    point_size : float
+        The size of screen-space points in pixels.
+    """
+
+    def __init__(self, viewport_width, viewport_height, point_size=1.0):
+        self.viewport_width = viewport_width
+        self.viewport_height = viewport_height
+        self.point_size = point_size
+
+        self._platform = None
+        self._renderer = None
+        self._create()
+
+    @property
+    def viewport_width(self):
+        """int : The width of the main viewport, in pixels.
+        """
+        return self._viewport_width
+
+    @viewport_width.setter
+    def viewport_width(self, value):
+        self._viewport_width = int(value)
+
+    @property
+    def viewport_height(self):
+        """int : The height of the main viewport, in pixels.
+        """
+        return self._viewport_height
+
+    @viewport_height.setter
+    def viewport_height(self, value):
+        self._viewport_height = int(value)
+
+    @property
+    def point_size(self):
+        """float : The pixel size of points in point clouds.
+        """
+        return self._point_size
+
+    @point_size.setter
+    def point_size(self, value):
+        self._point_size = float(value)
+
+    def render(self, scene, flags=RenderFlags.NONE, seg_node_map=None):
+        """Render a scene with the given set of flags.
+
+        Parameters
+        ----------
+        scene : :class:`Scene`
+            A scene to render.
+        flags : int
+            A bitwise or of one or more flags from :class:`.RenderFlags`.
+        seg_node_map : dict
+            A map from :class:`.Node` objects to (3,) colors for each.
+            If specified along with flags set to :attr:`.RenderFlags.SEG`,
+            the color image will be a segmentation image.
+
+        Returns
+        -------
+        color_im : (h, w, 3) uint8 or (h, w, 4) uint8
+            The color buffer in RGB format, or in RGBA format if
+            :attr:`.RenderFlags.RGBA` is set.
+            Not returned if flags includes :attr:`.RenderFlags.DEPTH_ONLY`.
+        depth_im : (h, w) float32
+            The depth buffer in linear units.
+        """
+        self._platform.make_current()
+        # If platform does not support dynamically-resizing framebuffers,
+        # destroy it and restart it
+        if (self._platform.viewport_height != self.viewport_height or
+                self._platform.viewport_width != self.viewport_width):
+            if not self._platform.supports_framebuffers():
+                self.delete()
+                self._create()
+
+        self._platform.make_current()
+        self._renderer.viewport_width = self.viewport_width
+        self._renderer.viewport_height = self.viewport_height
+        self._renderer.point_size = self.point_size
+
+        if self._platform.supports_framebuffers():
+            flags |= RenderFlags.OFFSCREEN
+            retval = self._renderer.render(scene, flags, seg_node_map)
+        else:
+            self._renderer.render(scene, flags, seg_node_map)
+            depth = self._renderer.read_depth_buf()
+            if flags & RenderFlags.DEPTH_ONLY:
+                retval = depth
+            else:
+                color = self._renderer.read_color_buf()
+                retval = color, depth
+
+        # Make the platform not current
+        self._platform.make_uncurrent()
+        return retval
+
+    def delete(self):
+        """Free all OpenGL resources.
+        """
+        self._platform.make_current()
+        self._renderer.delete()
+        self._platform.delete_context()
+        del self._renderer
+        del self._platform
+        self._renderer = None
+        self._platform = None
+        import gc
+        gc.collect()
+
+    def _create(self):
+        if 'PYOPENGL_PLATFORM' not in os.environ:
+            from pyrender.platforms.pyglet_platform import PygletPlatform
+            self._platform = PygletPlatform(self.viewport_width,
+                                            self.viewport_height)
+        elif os.environ['PYOPENGL_PLATFORM'] == 'egl':
+            from pyrender.platforms import egl
+            device_id = int(os.environ.get('EGL_DEVICE_ID', '0'))
+            egl_device = egl.get_device_by_index(device_id)
+            self._platform = egl.EGLPlatform(self.viewport_width,
+                                             self.viewport_height,
+                                             device=egl_device)
+        elif os.environ['PYOPENGL_PLATFORM'] == 'osmesa':
+            from pyrender.platforms.osmesa import OSMesaPlatform
+            self._platform = OSMesaPlatform(self.viewport_width,
+                                            self.viewport_height)
+        else:
+            raise ValueError('Unsupported PyOpenGL platform: {}'.format(
+                os.environ['PYOPENGL_PLATFORM']
+            ))
+        self._platform.init_context()
+        self._platform.make_current()
+        self._renderer = Renderer(self.viewport_width, self.viewport_height)
+
+    def __del__(self):
+        try:
+            self.delete()
+        except Exception:
+            pass
+
+
+__all__ = ['OffscreenRenderer']

pyrender/pyrender/platforms/__init__.py

@@ -0,0 +1,6 @@
+"""Platforms for generating offscreen OpenGL contexts for rendering.
+
+Author: Matthew Matl
+"""
+
+from .base import Platform

pyrender/pyrender/platforms/base.py

@@ -0,0 +1,76 @@
+import abc
+
+import six
+
+
+@six.add_metaclass(abc.ABCMeta)
+class Platform(object):
+    """Base class for all OpenGL platforms.
+
+    Parameters
+    ----------
+    viewport_width : int
+        The width of the main viewport, in pixels.
+    viewport_height : int
+        The height of the main viewport, in pixels
+    """
+
+    def __init__(self, viewport_width, viewport_height):
+        self.viewport_width = viewport_width
+        self.viewport_height = viewport_height
+
+    @property
+    def viewport_width(self):
+        """int : The width of the main viewport, in pixels.
+        """
+        return self._viewport_width
+
+    @viewport_width.setter
+    def viewport_width(self, value):
+        self._viewport_width = value
+
+    @property
+    def viewport_height(self):
+        """int : The height of the main viewport, in pixels.
+        """
+        return self._viewport_height
+
+    @viewport_height.setter
+    def viewport_height(self, value):
+        self._viewport_height = value
+
+    @abc.abstractmethod
+    def init_context(self):
+        """Create an OpenGL context.
+        """
+        pass
+
+    @abc.abstractmethod
+    def make_current(self):
+        """Make the OpenGL context current.
+        """
+        pass
+
+    @abc.abstractmethod
+    def make_uncurrent(self):
+        """Make the OpenGL context uncurrent.
+        """
+        pass
+
+    @abc.abstractmethod
+    def delete_context(self):
+        """Delete the OpenGL context.
+        """
+        pass
+
+    @abc.abstractmethod
+    def supports_framebuffers(self):
+        """Returns True if the method supports framebuffer rendering.
+        """
+        pass
+
+    def __del__(self):
+        try:
+            self.delete_context()
+        except Exception:
+            pass

pyrender/pyrender/platforms/egl.py

@@ -0,0 +1,219 @@
+import ctypes
+import os
+
+import OpenGL.platform
+
+from .base import Platform
+
+EGL_PLATFORM_DEVICE_EXT = 0x313F
+EGL_DRM_DEVICE_FILE_EXT = 0x3233
+
+
+def _ensure_egl_loaded():
+    plugin = OpenGL.platform.PlatformPlugin.by_name('egl')
+    if plugin is None:
+        raise RuntimeError("EGL platform plugin is not available.")
+
+    plugin_class = plugin.load()
+    plugin.loaded = True
+    # create instance of this platform implementation
+    plugin = plugin_class()
+
+    plugin.install(vars(OpenGL.platform))
+
+
+_ensure_egl_loaded()
+from OpenGL import EGL as egl
+
+
+def _get_egl_func(func_name, res_type, *arg_types):
+    address = egl.eglGetProcAddress(func_name)
+    if address is None:
+        return None
+
+    proto = ctypes.CFUNCTYPE(res_type)
+    proto.argtypes = arg_types
+    func = proto(address)
+    return func
+
+
+def _get_egl_struct(struct_name):
+    from OpenGL._opaque import opaque_pointer_cls
+    return opaque_pointer_cls(struct_name)
+
+
+# These are not defined in PyOpenGL by default.
+_EGLDeviceEXT = _get_egl_struct('EGLDeviceEXT')
+_eglGetPlatformDisplayEXT = _get_egl_func('eglGetPlatformDisplayEXT', egl.EGLDisplay)
+_eglQueryDevicesEXT = _get_egl_func('eglQueryDevicesEXT', egl.EGLBoolean)
+_eglQueryDeviceStringEXT = _get_egl_func('eglQueryDeviceStringEXT', ctypes.c_char_p)
+
+
+def query_devices():
+    if _eglQueryDevicesEXT is None:
+        raise RuntimeError("EGL query extension is not loaded or is not supported.")
+
+    num_devices = egl.EGLint()
+    success = _eglQueryDevicesEXT(0, None, ctypes.pointer(num_devices))
+    if not success or num_devices.value < 1:
+        return []
+
+    devices = (_EGLDeviceEXT * num_devices.value)()  # array of size num_devices
+    success = _eglQueryDevicesEXT(num_devices.value, devices, ctypes.pointer(num_devices))
+    if not success or num_devices.value < 1:
+        return []
+
+    return [EGLDevice(devices[i]) for i in range(num_devices.value)]
+
+
+def get_default_device():
+    # Fall back to not using query extension.
+    if _eglQueryDevicesEXT is None:
+        return EGLDevice(None)
+
+    return query_devices()[0]
+
+
+def get_device_by_index(device_id):
+    if _eglQueryDevicesEXT is None and device_id == 0:
+        return get_default_device()
+
+    devices = query_devices()
+    if device_id >= len(devices):
+        raise ValueError('Invalid device ID ({})'.format(device_id, len(devices)))
+    return devices[device_id]
+
+
+class EGLDevice:
+
+    def __init__(self, display=None):
+        self._display = display
+
+    def get_display(self):
+        if self._display is None:
+            return egl.eglGetDisplay(egl.EGL_DEFAULT_DISPLAY)
+
+        return _eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, self._display, None)
+
+    @property
+    def name(self):
+        if self._display is None:
+            return 'default'
+
+        name = _eglQueryDeviceStringEXT(self._display, EGL_DRM_DEVICE_FILE_EXT)
+        if name is None:
+            return None
+
+        return name.decode('ascii')
+
+    def __repr__(self):
+        return "<EGLDevice(name={})>".format(self.name)
+
+
+class EGLPlatform(Platform):
+    """Renders using EGL.
+    """
+
+    def __init__(self, viewport_width, viewport_height, device: EGLDevice = None):
+        super(EGLPlatform, self).__init__(viewport_width, viewport_height)
+        if device is None:
+            device = get_default_device()
+
+        self._egl_device = device
+        self._egl_display = None
+        self._egl_context = None
+
+    def init_context(self):
+        _ensure_egl_loaded()
+
+        from OpenGL.EGL import (
+            EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_BLUE_SIZE,
+            EGL_RED_SIZE, EGL_GREEN_SIZE, EGL_DEPTH_SIZE,
+            EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER,
+            EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT, EGL_CONFORMANT,
+            EGL_NONE, EGL_DEFAULT_DISPLAY, EGL_NO_CONTEXT,
+            EGL_OPENGL_API, EGL_CONTEXT_MAJOR_VERSION,
+            EGL_CONTEXT_MINOR_VERSION,
+            EGL_CONTEXT_OPENGL_PROFILE_MASK,
+            EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT,
+            eglGetDisplay, eglInitialize, eglChooseConfig,
+            eglBindAPI, eglCreateContext, EGLConfig
+        )
+        from OpenGL import arrays
+
+        config_attributes = arrays.GLintArray.asArray([
+            EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+            EGL_BLUE_SIZE, 8,
+            EGL_RED_SIZE, 8,
+            EGL_GREEN_SIZE, 8,
+            EGL_DEPTH_SIZE, 24,
+            EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER,
+            EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
+            EGL_CONFORMANT, EGL_OPENGL_BIT,
+            EGL_NONE
+        ])
+        context_attributes = arrays.GLintArray.asArray([
+            EGL_CONTEXT_MAJOR_VERSION, 4,
+            EGL_CONTEXT_MINOR_VERSION, 1,
+            EGL_CONTEXT_OPENGL_PROFILE_MASK,
+            EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT,
+            EGL_NONE
+        ])
+        major, minor = ctypes.c_long(), ctypes.c_long()
+        num_configs = ctypes.c_long()
+        configs = (EGLConfig * 1)()
+
+        # Cache DISPLAY if necessary and get an off-screen EGL display
+        orig_dpy = None
+        if 'DISPLAY' in os.environ:
+            orig_dpy = os.environ['DISPLAY']
+            del os.environ['DISPLAY']
+
+        self._egl_display = self._egl_device.get_display()
+        if orig_dpy is not None:
+            os.environ['DISPLAY'] = orig_dpy
+
+        # Initialize EGL
+        assert eglInitialize(self._egl_display, major, minor)
+        assert eglChooseConfig(
+            self._egl_display, config_attributes, configs, 1, num_configs
+        )
+
+        # Bind EGL to the OpenGL API
+        assert eglBindAPI(EGL_OPENGL_API)
+
+        # Create an EGL context
+        self._egl_context = eglCreateContext(
+            self._egl_display, configs[0],
+            EGL_NO_CONTEXT, context_attributes
+        )
+
+        # Make it current
+        self.make_current()
+
+    def make_current(self):
+        from OpenGL.EGL import eglMakeCurrent, EGL_NO_SURFACE
+        assert eglMakeCurrent(
+            self._egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
+            self._egl_context
+        )
+
+    def make_uncurrent(self):
+        """Make the OpenGL context uncurrent.
+        """
+        pass
+
+    def delete_context(self):
+        from OpenGL.EGL import eglDestroyContext, eglTerminate
+        if self._egl_display is not None:
+            if self._egl_context is not None:
+                eglDestroyContext(self._egl_display, self._egl_context)
+                self._egl_context = None
+            eglTerminate(self._egl_display)
+            self._egl_display = None
+
+    def supports_framebuffers(self):
+        return True
+
+
+__all__ = ['EGLPlatform']

pyrender/pyrender/platforms/osmesa.py

@@ -0,0 +1,59 @@
+from .base import Platform
+
+
+__all__ = ['OSMesaPlatform']
+
+
+class OSMesaPlatform(Platform):
+    """Renders into a software buffer using OSMesa. Requires special versions
+    of OSMesa to be installed, plus PyOpenGL upgrade.
+    """
+
+    def __init__(self, viewport_width, viewport_height):
+        super(OSMesaPlatform, self).__init__(viewport_width, viewport_height)
+        self._context = None
+        self._buffer = None
+
+    def init_context(self):
+        from OpenGL import arrays
+        from OpenGL.osmesa import (
+            OSMesaCreateContextAttribs, OSMESA_FORMAT,
+            OSMESA_RGBA, OSMESA_PROFILE, OSMESA_CORE_PROFILE,
+            OSMESA_CONTEXT_MAJOR_VERSION, OSMESA_CONTEXT_MINOR_VERSION,
+            OSMESA_DEPTH_BITS
+        )
+
+        attrs = arrays.GLintArray.asArray([
+            OSMESA_FORMAT, OSMESA_RGBA,
+            OSMESA_DEPTH_BITS, 24,
+            OSMESA_PROFILE, OSMESA_CORE_PROFILE,
+            OSMESA_CONTEXT_MAJOR_VERSION, 3,
+            OSMESA_CONTEXT_MINOR_VERSION, 3,
+            0
+        ])
+        self._context = OSMesaCreateContextAttribs(attrs, None)
+        self._buffer = arrays.GLubyteArray.zeros(
+            (self.viewport_height, self.viewport_width, 4)
+        )
+
+    def make_current(self):
+        from OpenGL import GL as gl
+        from OpenGL.osmesa import OSMesaMakeCurrent
+        assert(OSMesaMakeCurrent(
+            self._context, self._buffer, gl.GL_UNSIGNED_BYTE,
+            self.viewport_width, self.viewport_height
+        ))
+
+    def make_uncurrent(self):
+        """Make the OpenGL context uncurrent.
+        """
+        pass
+
+    def delete_context(self):
+        from OpenGL.osmesa import OSMesaDestroyContext
+        OSMesaDestroyContext(self._context)
+        self._context = None
+        self._buffer = None
+
+    def supports_framebuffers(self):
+        return False

pyrender/pyrender/platforms/pyglet_platform.py

@@ -0,0 +1,90 @@
+from pyrender.constants import (TARGET_OPEN_GL_MAJOR, TARGET_OPEN_GL_MINOR,
+                                MIN_OPEN_GL_MAJOR, MIN_OPEN_GL_MINOR)
+from .base import Platform
+
+import OpenGL
+
+
+__all__ = ['PygletPlatform']
+
+
+class PygletPlatform(Platform):
+    """Renders on-screen using a 1x1 hidden Pyglet window for getting
+    an OpenGL context.
+    """
+
+    def __init__(self, viewport_width, viewport_height):
+        super(PygletPlatform, self).__init__(viewport_width, viewport_height)
+        self._window = None
+
+    def init_context(self):
+        import pyglet
+        pyglet.options['shadow_window'] = False
+
+        try:
+            pyglet.lib.x11.xlib.XInitThreads()
+        except Exception:
+            pass
+
+        self._window = None
+        confs = [pyglet.gl.Config(sample_buffers=1, samples=4,
+                                  depth_size=24,
+                                  double_buffer=True,
+                                  major_version=TARGET_OPEN_GL_MAJOR,
+                                  minor_version=TARGET_OPEN_GL_MINOR),
+                 pyglet.gl.Config(depth_size=24,
+                                  double_buffer=True,
+                                  major_version=TARGET_OPEN_GL_MAJOR,
+                                  minor_version=TARGET_OPEN_GL_MINOR),
+                 pyglet.gl.Config(sample_buffers=1, samples=4,
+                                  depth_size=24,
+                                  double_buffer=True,
+                                  major_version=MIN_OPEN_GL_MAJOR,
+                                  minor_version=MIN_OPEN_GL_MINOR),
+                 pyglet.gl.Config(depth_size=24,
+                                  double_buffer=True,
+                                  major_version=MIN_OPEN_GL_MAJOR,
+                                  minor_version=MIN_OPEN_GL_MINOR)]
+        for conf in confs:
+            try:
+                self._window = pyglet.window.Window(config=conf, visible=False,
+                                                    resizable=False,
+                                                    width=1, height=1)
+                break
+            except pyglet.window.NoSuchConfigException as e:
+                pass
+
+        if not self._window:
+            raise ValueError(
+                'Failed to initialize Pyglet window with an OpenGL >= 3+ '
+                'context. If you\'re logged in via SSH, ensure that you\'re '
+                'running your script with vglrun (i.e. VirtualGL). The '
+                'internal error message was "{}"'.format(e)
+            )
+
+    def make_current(self):
+        if self._window:
+            self._window.switch_to()
+
+    def make_uncurrent(self):
+        try:
+            import pyglet
+            pyglet.gl.xlib.glx.glXMakeContextCurrent(self._window.context.x_display, 0, 0, None)
+        except Exception:
+            pass
+
+    def delete_context(self):
+        if self._window is not None:
+            self.make_current()
+            cid = OpenGL.contextdata.getContext()
+            try:
+                self._window.context.destroy()
+                self._window.close()
+            except Exception:
+                pass
+            self._window = None
+            OpenGL.contextdata.cleanupContext(cid)
+            del cid
+
+    def supports_framebuffers(self):
+        return True

pyrender/pyrender/primitive.py

@@ -0,0 +1,489 @@
+"""Primitives, conforming to the glTF 2.0 standards as specified in
+https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-primitive
+
+Author: Matthew Matl
+"""
+import numpy as np
+
+from OpenGL.GL import *
+
+from .material import Material, MetallicRoughnessMaterial
+from .constants import FLOAT_SZ, UINT_SZ, BufFlags, GLTF
+from .utils import format_color_array
+
+
+class Primitive(object):
+    """A primitive object which can be rendered.
+
+    Parameters
+    ----------
+    positions : (n, 3) float
+        XYZ vertex positions.
+    normals : (n, 3) float
+        Normalized XYZ vertex normals.
+    tangents : (n, 4) float
+        XYZW vertex tangents where the w component is a sign value
+        (either +1 or -1) indicating the handedness of the tangent basis.
+    texcoord_0 : (n, 2) float
+        The first set of UV texture coordinates.
+    texcoord_1 : (n, 2) float
+        The second set of UV texture coordinates.
+    color_0 : (n, 4) float
+        RGBA vertex colors.
+    joints_0 : (n, 4) float
+        Joint information.
+    weights_0 : (n, 4) float
+        Weight information for morphing.
+    indices : (m, 3) int
+        Face indices for triangle meshes or fans.
+    material : :class:`Material`
+        The material to apply to this primitive when rendering.
+    mode : int
+        The type of primitives to render, one of the following:
+
+        - ``0``: POINTS
+        - ``1``: LINES
+        - ``2``: LINE_LOOP
+        - ``3``: LINE_STRIP
+        - ``4``: TRIANGLES
+        - ``5``: TRIANGLES_STRIP
+        - ``6``: TRIANGLES_FAN
+    targets : (k,) int
+        Morph target indices.
+    poses : (x,4,4), float
+        Array of 4x4 transformation matrices for instancing this object.
+    """
+
+    def __init__(self,
+                 positions,
+                 normals=None,
+                 tangents=None,
+                 texcoord_0=None,
+                 texcoord_1=None,
+                 color_0=None,
+                 joints_0=None,
+                 weights_0=None,
+                 indices=None,
+                 material=None,
+                 mode=None,
+                 targets=None,
+                 poses=None):
+
+        if mode is None:
+            mode = GLTF.TRIANGLES
+
+        self.positions = positions
+        self.normals = normals
+        self.tangents = tangents
+        self.texcoord_0 = texcoord_0
+        self.texcoord_1 = texcoord_1
+        self.color_0 = color_0
+        self.joints_0 = joints_0
+        self.weights_0 = weights_0
+        self.indices = indices
+        self.material = material
+        self.mode = mode
+        self.targets = targets
+        self.poses = poses
+
+        self._bounds = None
+        self._vaid = None
+        self._buffers = []
+        self._is_transparent = None
+        self._buf_flags = None
+
+    @property
+    def positions(self):
+        """(n,3) float : XYZ vertex positions.
+        """
+        return self._positions
+
+    @positions.setter
+    def positions(self, value):
+        value = np.asanyarray(value, dtype=np.float32)
+        self._positions = np.ascontiguousarray(value)
+        self._bounds = None
+
+    @property
+    def normals(self):
+        """(n,3) float : Normalized XYZ vertex normals.
+        """
+        return self._normals
+
+    @normals.setter
+    def normals(self, value):
+        if value is not None:
+            value = np.asanyarray(value, dtype=np.float32)
+            value = np.ascontiguousarray(value)
+            if value.shape != self.positions.shape:
+                raise ValueError('Incorrect normals shape')
+        self._normals = value
+
+    @property
+    def tangents(self):
+        """(n,4) float : XYZW vertex tangents.
+        """
+        return self._tangents
+
+    @tangents.setter
+    def tangents(self, value):
+        if value is not None:
+            value = np.asanyarray(value, dtype=np.float32)
+            value = np.ascontiguousarray(value)
+            if value.shape != (self.positions.shape[0], 4):
+                raise ValueError('Incorrect tangent shape')
+        self._tangents = value
+
+    @property
+    def texcoord_0(self):
+        """(n,2) float : The first set of UV texture coordinates.
+        """
+        return self._texcoord_0
+
+    @texcoord_0.setter
+    def texcoord_0(self, value):
+        if value is not None:
+            value = np.asanyarray(value, dtype=np.float32)
+            value = np.ascontiguousarray(value)
+            if (value.ndim != 2 or value.shape[0] != self.positions.shape[0] or
+                    value.shape[1] < 2):
+                raise ValueError('Incorrect texture coordinate shape')
+            if value.shape[1] > 2:
+                value = value[:,:2]
+        self._texcoord_0 = value
+
+    @property
+    def texcoord_1(self):
+        """(n,2) float : The second set of UV texture coordinates.
+        """
+        return self._texcoord_1
+
+    @texcoord_1.setter
+    def texcoord_1(self, value):
+        if value is not None:
+            value = np.asanyarray(value, dtype=np.float32)
+            value = np.ascontiguousarray(value)
+            if (value.ndim != 2 or value.shape[0] != self.positions.shape[0] or
+                    value.shape[1] != 2):
+                raise ValueError('Incorrect texture coordinate shape')
+        self._texcoord_1 = value
+
+    @property
+    def color_0(self):
+        """(n,4) float : RGBA vertex colors.
+        """
+        return self._color_0
+
+    @color_0.setter
+    def color_0(self, value):
+        if value is not None:
+            value = np.ascontiguousarray(
+                format_color_array(value, shape=(len(self.positions), 4))
+            )
+        self._is_transparent = None
+        self._color_0 = value
+
+    @property
+    def joints_0(self):
+        """(n,4) float : Joint information.
+        """
+        return self._joints_0
+
+    @joints_0.setter
+    def joints_0(self, value):
+        self._joints_0 = value
+
+    @property
+    def weights_0(self):
+        """(n,4) float : Weight information for morphing.
+        """
+        return self._weights_0
+
+    @weights_0.setter
+    def weights_0(self, value):
+        self._weights_0 = value
+
+    @property
+    def indices(self):
+        """(m,3) int : Face indices for triangle meshes or fans.
+        """
+        return self._indices
+
+    @indices.setter
+    def indices(self, value):
+        if value is not None:
+            value = np.asanyarray(value, dtype=np.float32)
+            value = np.ascontiguousarray(value)
+        self._indices = value
+
+    @property
+    def material(self):
+        """:class:`Material` : The material for this primitive.
+        """
+        return self._material
+
+    @material.setter
+    def material(self, value):
+        # Create default material
+        if value is None:
+            value = MetallicRoughnessMaterial()
+        else:
+            if not isinstance(value, Material):
+                raise TypeError('Object material must be of type Material')
+        self._material = value
+
+    @property
+    def mode(self):
+        """int : The type of primitive to render.
+        """
+        return self._mode
+
+    @mode.setter
+    def mode(self, value):
+        value = int(value)
+        if value < GLTF.POINTS or value > GLTF.TRIANGLE_FAN:
+            raise ValueError('Invalid mode')
+        self._mode = value
+
+    @property
+    def targets(self):
+        """(k,) int : Morph target indices.
+        """
+        return self._targets
+
+    @targets.setter
+    def targets(self, value):
+        self._targets = value
+
+    @property
+    def poses(self):
+        """(x,4,4) float : Homogenous transforms for instancing this primitive.
+        """
+        return self._poses
+
+    @poses.setter
+    def poses(self, value):
+        if value is not None:
+            value = np.asanyarray(value, dtype=np.float32)
+            value = np.ascontiguousarray(value)
+            if value.ndim == 2:
+                value = value[np.newaxis,:,:]
+            if value.shape[1] != 4 or value.shape[2] != 4:
+                raise ValueError('Pose matrices must be of shape (n,4,4), '
+                                 'got {}'.format(value.shape))
+        self._poses = value
+        self._bounds = None
+
+    @property
+    def bounds(self):
+        if self._bounds is None:
+            self._bounds = self._compute_bounds()
+        return self._bounds
+
+    @property
+    def centroid(self):
+        """(3,) float : The centroid of the primitive's AABB.
+        """
+        return np.mean(self.bounds, axis=0)
+
+    @property
+    def extents(self):
+        """(3,) float : The lengths of the axes of the primitive's AABB.
+        """
+        return np.diff(self.bounds, axis=0).reshape(-1)
+
+    @property
+    def scale(self):
+        """(3,) float : The length of the diagonal of the primitive's AABB.
+        """
+        return np.linalg.norm(self.extents)
+
+    @property
+    def buf_flags(self):
+        """int : The flags for the render buffer.
+        """
+        if self._buf_flags is None:
+            self._buf_flags = self._compute_buf_flags()
+        return self._buf_flags
+
+    def delete(self):
+        self._unbind()
+        self._remove_from_context()
+
+    @property
+    def is_transparent(self):
+        """bool : If True, the mesh is partially-transparent.
+        """
+        return self._compute_transparency()
+
+    def _add_to_context(self):
+        if self._vaid is not None:
+            raise ValueError('Mesh is already bound to a context')
+
+        # Generate and bind VAO
+        self._vaid = glGenVertexArrays(1)
+        glBindVertexArray(self._vaid)
+
+        #######################################################################
+        # Fill vertex buffer
+        #######################################################################
+
+        # Generate and bind vertex buffer
+        vertexbuffer = glGenBuffers(1)
+        self._buffers.append(vertexbuffer)
+        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer)
+
+        # positions
+        vertex_data = self.positions
+        attr_sizes = [3]
+
+        # Normals
+        if self.normals is not None:
+            vertex_data = np.hstack((vertex_data, self.normals))
+            attr_sizes.append(3)
+
+        # Tangents
+        if self.tangents is not None:
+            vertex_data = np.hstack((vertex_data, self.tangents))
+            attr_sizes.append(4)
+
+        # Texture Coordinates
+        if self.texcoord_0 is not None:
+            vertex_data = np.hstack((vertex_data, self.texcoord_0))
+            attr_sizes.append(2)
+        if self.texcoord_1 is not None:
+            vertex_data = np.hstack((vertex_data, self.texcoord_1))
+            attr_sizes.append(2)
+
+        # Color
+        if self.color_0 is not None:
+            vertex_data = np.hstack((vertex_data, self.color_0))
+            attr_sizes.append(4)
+
+        # TODO JOINTS AND WEIGHTS
+        # PASS
+
+        # Copy data to buffer
+        vertex_data = np.ascontiguousarray(
+            vertex_data.flatten().astype(np.float32)
+        )
+        glBufferData(
+            GL_ARRAY_BUFFER, FLOAT_SZ * len(vertex_data),
+            vertex_data, GL_STATIC_DRAW
+        )
+        total_sz = sum(attr_sizes)
+        offset = 0
+        for i, sz in enumerate(attr_sizes):
+            glVertexAttribPointer(
+                i, sz, GL_FLOAT, GL_FALSE, FLOAT_SZ * total_sz,
+                ctypes.c_void_p(FLOAT_SZ * offset)
+            )
+            glEnableVertexAttribArray(i)
+            offset += sz
+
+        #######################################################################
+        # Fill model matrix buffer
+        #######################################################################
+
+        if self.poses is not None:
+            pose_data = np.ascontiguousarray(
+                np.transpose(self.poses, [0,2,1]).flatten().astype(np.float32)
+            )
+        else:
+            pose_data = np.ascontiguousarray(
+                np.eye(4).flatten().astype(np.float32)
+            )
+
+        modelbuffer = glGenBuffers(1)
+        self._buffers.append(modelbuffer)
+        glBindBuffer(GL_ARRAY_BUFFER, modelbuffer)
+        glBufferData(
+            GL_ARRAY_BUFFER, FLOAT_SZ * len(pose_data),
+            pose_data, GL_STATIC_DRAW
+        )
+
+        for i in range(0, 4):
+            idx = i + len(attr_sizes)
+            glEnableVertexAttribArray(idx)
+            glVertexAttribPointer(
+                idx, 4, GL_FLOAT, GL_FALSE, FLOAT_SZ * 4 * 4,
+                ctypes.c_void_p(4 * FLOAT_SZ * i)
+            )
+            glVertexAttribDivisor(idx, 1)
+
+        #######################################################################
+        # Fill element buffer
+        #######################################################################
+        if self.indices is not None:
+            elementbuffer = glGenBuffers(1)
+            self._buffers.append(elementbuffer)
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementbuffer)
+            glBufferData(GL_ELEMENT_ARRAY_BUFFER, UINT_SZ * self.indices.size,
+                         self.indices.flatten().astype(np.uint32),
+                         GL_STATIC_DRAW)
+
+        glBindVertexArray(0)
+
+    def _remove_from_context(self):
+        if self._vaid is not None:
+            glDeleteVertexArrays(1, [self._vaid])
+            glDeleteBuffers(len(self._buffers), self._buffers)
+            self._vaid = None
+            self._buffers = []
+
+    def _in_context(self):
+        return self._vaid is not None
+
+    def _bind(self):
+        if self._vaid is None:
+            raise ValueError('Cannot bind a Mesh that has not been added '
+                             'to a context')
+        glBindVertexArray(self._vaid)
+
+    def _unbind(self):
+        glBindVertexArray(0)
+
+    def _compute_bounds(self):
+        """Compute the bounds of this object.
+        """
+        # Compute bounds of this object
+        bounds = np.array([np.min(self.positions, axis=0),
+                           np.max(self.positions, axis=0)])
+
+        # If instanced, compute translations for approximate bounds
+        if self.poses is not None:
+            bounds += np.array([np.min(self.poses[:,:3,3], axis=0),
+                                np.max(self.poses[:,:3,3], axis=0)])
+        return bounds
+
+    def _compute_transparency(self):
+        """Compute whether or not this object is transparent.
+        """
+        if self.material.is_transparent:
+            return True
+        if self._is_transparent is None:
+            self._is_transparent = False
+            if self.color_0 is not None:
+                if np.any(self._color_0[:,3] != 1.0):
+                    self._is_transparent = True
+        return self._is_transparent
+
+    def _compute_buf_flags(self):
+        buf_flags = BufFlags.POSITION
+
+        if self.normals is not None:
+            buf_flags |= BufFlags.NORMAL
+        if self.tangents is not None:
+            buf_flags |= BufFlags.TANGENT
+        if self.texcoord_0 is not None:
+            buf_flags |= BufFlags.TEXCOORD_0
+        if self.texcoord_1 is not None:
+            buf_flags |= BufFlags.TEXCOORD_1
+        if self.color_0 is not None:
+            buf_flags |= BufFlags.COLOR_0
+        if self.joints_0 is not None:
+            buf_flags |= BufFlags.JOINTS_0
+        if self.weights_0 is not None:
+            buf_flags |= BufFlags.WEIGHTS_0
+
+        return buf_flags

pyrender/pyrender/renderer.py

@@ -0,0 +1,1339 @@
+"""PBR renderer for Python.
+
+Author: Matthew Matl
+"""
+import sys
+
+import numpy as np
+import PIL
+
+from .constants import (RenderFlags, TextAlign, GLTF, BufFlags, TexFlags,
+                        ProgramFlags, DEFAULT_Z_FAR, DEFAULT_Z_NEAR,
+                        SHADOW_TEX_SZ, MAX_N_LIGHTS)
+from .shader_program import ShaderProgramCache
+from .material import MetallicRoughnessMaterial, SpecularGlossinessMaterial
+from .light import PointLight, SpotLight, DirectionalLight
+from .font import FontCache
+from .utils import format_color_vector
+
+from OpenGL.GL import *
+
+
+class Renderer(object):
+    """Class for handling all rendering operations on a scene.
+
+    Note
+    ----
+    This renderer relies on the existence of an OpenGL context and
+    does not create one on its own.
+
+    Parameters
+    ----------
+    viewport_width : int
+        Width of the viewport in pixels.
+    viewport_height : int
+        Width of the viewport height in pixels.
+    point_size : float, optional
+        Size of points in pixels. Defaults to 1.0.
+    """
+
+    def __init__(self, viewport_width, viewport_height, point_size=1.0):
+        self.dpscale = 1
+        # Scaling needed on retina displays
+        if sys.platform == 'darwin':
+            self.dpscale = 2
+
+        self.viewport_width = viewport_width
+        self.viewport_height = viewport_height
+        self.point_size = point_size
+
+        # Optional framebuffer for offscreen renders
+        self._main_fb = None
+        self._main_cb = None
+        self._main_db = None
+        self._main_fb_ms = None
+        self._main_cb_ms = None
+        self._main_db_ms = None
+        self._main_fb_dims = (None, None)
+        self._shadow_fb = None
+        self._latest_znear = DEFAULT_Z_NEAR
+        self._latest_zfar = DEFAULT_Z_FAR
+
+        # Shader Program Cache
+        self._program_cache = ShaderProgramCache()
+        self._font_cache = FontCache()
+        self._meshes = set()
+        self._mesh_textures = set()
+        self._shadow_textures = set()
+        self._texture_alloc_idx = 0
+
+    @property
+    def viewport_width(self):
+        """int : The width of the main viewport, in pixels.
+        """
+        return self._viewport_width
+
+    @viewport_width.setter
+    def viewport_width(self, value):
+        self._viewport_width = self.dpscale * value
+
+    @property
+    def viewport_height(self):
+        """int : The height of the main viewport, in pixels.
+        """
+        return self._viewport_height
+
+    @viewport_height.setter
+    def viewport_height(self, value):
+        self._viewport_height = self.dpscale * value
+
+    @property
+    def point_size(self):
+        """float : The size of screen-space points, in pixels.
+        """
+        return self._point_size
+
+    @point_size.setter
+    def point_size(self, value):
+        self._point_size = float(value)
+
+    def render(self, scene, flags, seg_node_map=None):
+        """Render a scene with the given set of flags.
+
+        Parameters
+        ----------
+        scene : :class:`Scene`
+            A scene to render.
+        flags : int
+            A specification from :class:`.RenderFlags`.
+        seg_node_map : dict
+            A map from :class:`.Node` objects to (3,) colors for each.
+            If specified along with flags set to :attr:`.RenderFlags.SEG`,
+            the color image will be a segmentation image.
+
+        Returns
+        -------
+        color_im : (h, w, 3) uint8 or (h, w, 4) uint8
+            If :attr:`RenderFlags.OFFSCREEN` is set, the color buffer. This is
+            normally an RGB buffer, but if :attr:`.RenderFlags.RGBA` is set,
+            the buffer will be a full RGBA buffer.
+        depth_im : (h, w) float32
+            If :attr:`RenderFlags.OFFSCREEN` is set, the depth buffer
+            in linear units.
+        """
+        # Update context with meshes and textures
+        self._update_context(scene, flags)
+
+        # Render necessary shadow maps
+        if not bool(flags & RenderFlags.DEPTH_ONLY or flags & RenderFlags.SEG):
+            for ln in scene.light_nodes:
+                take_pass = False
+                if (isinstance(ln.light, DirectionalLight) and
+                        bool(flags & RenderFlags.SHADOWS_DIRECTIONAL)):
+                    take_pass = True
+                elif (isinstance(ln.light, SpotLight) and
+                        bool(flags & RenderFlags.SHADOWS_SPOT)):
+                    take_pass = True
+                elif (isinstance(ln.light, PointLight) and
+                        bool(flags & RenderFlags.SHADOWS_POINT)):
+                    take_pass = True
+                if take_pass:
+                    self._shadow_mapping_pass(scene, ln, flags)
+
+        # Make forward pass
+        retval = self._forward_pass(scene, flags, seg_node_map=seg_node_map)
+
+        # If necessary, make normals pass
+        if flags & (RenderFlags.VERTEX_NORMALS | RenderFlags.FACE_NORMALS):
+            self._normals_pass(scene, flags)
+
+        # Update camera settings for retrieving depth buffers
+        self._latest_znear = scene.main_camera_node.camera.znear
+        self._latest_zfar = scene.main_camera_node.camera.zfar
+
+        return retval
+
+    def render_text(self, text, x, y, font_name='OpenSans-Regular',
+                    font_pt=40, color=None, scale=1.0,
+                    align=TextAlign.BOTTOM_LEFT):
+        """Render text into the current viewport.
+
+        Note
+        ----
+        This cannot be done into an offscreen buffer.
+
+        Parameters
+        ----------
+        text : str
+            The text to render.
+        x : int
+            Horizontal pixel location of text.
+        y : int
+            Vertical pixel location of text.
+        font_name : str
+            Name of font, from the ``pyrender/fonts`` folder, or
+            a path to a ``.ttf`` file.
+        font_pt : int
+            Height of the text, in font points.
+        color : (4,) float
+            The color of the text. Default is black.
+        scale : int
+            Scaling factor for text.
+        align : int
+            One of the :class:`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.
+        """
+        x *= self.dpscale
+        y *= self.dpscale
+        font_pt *= self.dpscale
+
+        if color is None:
+            color = np.array([0.0, 0.0, 0.0, 1.0])
+        else:
+            color = format_color_vector(color, 4)
+
+        # Set up viewport for render
+        self._configure_forward_pass_viewport(0)
+
+        # Load font
+        font = self._font_cache.get_font(font_name, font_pt)
+        if not font._in_context():
+            font._add_to_context()
+
+        # Load program
+        program = self._get_text_program()
+        program._bind()
+
+        # Set uniforms
+        p = np.eye(4)
+        p[0,0] = 2.0 / self.viewport_width
+        p[0,3] = -1.0
+        p[1,1] = 2.0 / self.viewport_height
+        p[1,3] = -1.0
+        program.set_uniform('projection', p)
+        program.set_uniform('text_color', color)
+
+        # Draw text
+        font.render_string(text, x, y, scale, align)
+
+    def read_color_buf(self):
+        """Read and return the current viewport's color buffer.
+
+        Alpha cannot be computed for an on-screen buffer.
+
+        Returns
+        -------
+        color_im : (h, w, 3) uint8
+            The color buffer in RGB byte format.
+        """
+        # Extract color image from frame buffer
+        width, height = self.viewport_width, self.viewport_height
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, 0)
+        glReadBuffer(GL_FRONT)
+        color_buf = glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE)
+
+        # Re-format them into numpy arrays
+        color_im = np.frombuffer(color_buf, dtype=np.uint8)
+        color_im = color_im.reshape((height, width, 3))
+        color_im = np.flip(color_im, axis=0)
+
+        # Resize for macos if needed
+        if sys.platform == 'darwin':
+            color_im = self._resize_image(color_im, True)
+
+        return color_im
+
+    def read_depth_buf(self):
+        """Read and return the current viewport's color buffer.
+
+        Returns
+        -------
+        depth_im : (h, w) float32
+            The depth buffer in linear units.
+        """
+        width, height = self.viewport_width, self.viewport_height
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, 0)
+        glReadBuffer(GL_FRONT)
+        depth_buf = glReadPixels(
+            0, 0, width, height, GL_DEPTH_COMPONENT, GL_FLOAT
+        )
+
+        depth_im = np.frombuffer(depth_buf, dtype=np.float32)
+        depth_im = depth_im.reshape((height, width))
+        depth_im = np.flip(depth_im, axis=0)
+
+        inf_inds = (depth_im == 1.0)
+        depth_im = 2.0 * depth_im - 1.0
+        z_near, z_far = self._latest_znear, self._latest_zfar
+        noninf = np.logical_not(inf_inds)
+        if z_far is None:
+            depth_im[noninf] = 2 * z_near / (1.0 - depth_im[noninf])
+        else:
+            depth_im[noninf] = ((2.0 * z_near * z_far) /
+                                (z_far + z_near - depth_im[noninf] *
+                                (z_far - z_near)))
+        depth_im[inf_inds] = 0.0
+
+        # Resize for macos if needed
+        if sys.platform == 'darwin':
+            depth_im = self._resize_image(depth_im)
+
+        return depth_im
+
+    def delete(self):
+        """Free all allocated OpenGL resources.
+        """
+        # Free shaders
+        self._program_cache.clear()
+
+        # Free fonts
+        self._font_cache.clear()
+
+        # Free meshes
+        for mesh in self._meshes:
+            for p in mesh.primitives:
+                p.delete()
+
+        # Free textures
+        for mesh_texture in self._mesh_textures:
+            mesh_texture.delete()
+
+        for shadow_texture in self._shadow_textures:
+            shadow_texture.delete()
+
+        self._meshes = set()
+        self._mesh_textures = set()
+        self._shadow_textures = set()
+        self._texture_alloc_idx = 0
+
+        self._delete_main_framebuffer()
+        self._delete_shadow_framebuffer()
+
+    def __del__(self):
+        try:
+            self.delete()
+        except Exception:
+            pass
+
+    ###########################################################################
+    # Rendering passes
+    ###########################################################################
+
+    def _forward_pass(self, scene, flags, seg_node_map=None):
+        # Set up viewport for render
+        self._configure_forward_pass_viewport(flags)
+
+        # Clear it
+        if bool(flags & RenderFlags.SEG):
+            glClearColor(0.0, 0.0, 0.0, 1.0)
+            if seg_node_map is None:
+                seg_node_map = {}
+        else:
+            glClearColor(*scene.bg_color)
+
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+        if not bool(flags & RenderFlags.SEG):
+            glEnable(GL_MULTISAMPLE)
+        else:
+            glDisable(GL_MULTISAMPLE)
+
+        # Set up camera matrices
+        V, P = self._get_camera_matrices(scene)
+
+        program = None
+        # Now, render each object in sorted order
+        for node in self._sorted_mesh_nodes(scene):
+            mesh = node.mesh
+
+            # Skip the mesh if it's not visible
+            if not mesh.is_visible:
+                continue
+
+            # If SEG, set color
+            if bool(flags & RenderFlags.SEG):
+                if node not in seg_node_map:
+                    continue
+                color = seg_node_map[node]
+                if not isinstance(color, (list, tuple, np.ndarray)):
+                    color = np.repeat(color, 3)
+                else:
+                    color = np.asanyarray(color)
+                color = color / 255.0
+
+            for primitive in mesh.primitives:
+
+                # First, get and bind the appropriate program
+                program = self._get_primitive_program(
+                    primitive, flags, ProgramFlags.USE_MATERIAL
+                )
+                program._bind()
+
+                # Set the camera uniforms
+                program.set_uniform('V', V)
+                program.set_uniform('P', P)
+                program.set_uniform(
+                    'cam_pos', scene.get_pose(scene.main_camera_node)[:3,3]
+                )
+                if bool(flags & RenderFlags.SEG):
+                    program.set_uniform('color', color)
+
+                # Next, bind the lighting
+                if not (flags & RenderFlags.DEPTH_ONLY or flags & RenderFlags.FLAT or
+                        flags & RenderFlags.SEG):
+                    self._bind_lighting(scene, program, node, flags)
+
+                # Finally, bind and draw the primitive
+                self._bind_and_draw_primitive(
+                    primitive=primitive,
+                    pose=scene.get_pose(node),
+                    program=program,
+                    flags=flags
+                )
+                self._reset_active_textures()
+
+        # Unbind the shader and flush the output
+        if program is not None:
+            program._unbind()
+        glFlush()
+
+        # If doing offscreen render, copy result from framebuffer and return
+        if flags & RenderFlags.OFFSCREEN:
+            return self._read_main_framebuffer(scene, flags)
+        else:
+            return
+
+    def _shadow_mapping_pass(self, scene, light_node, flags):
+        light = light_node.light
+
+        # Set up viewport for render
+        self._configure_shadow_mapping_viewport(light, flags)
+
+        # Set up camera matrices
+        V, P = self._get_light_cam_matrices(scene, light_node, flags)
+
+        # Now, render each object in sorted order
+        for node in self._sorted_mesh_nodes(scene):
+            mesh = node.mesh
+
+            # Skip the mesh if it's not visible
+            if not mesh.is_visible:
+                continue
+
+            for primitive in mesh.primitives:
+
+                # First, get and bind the appropriate program
+                program = self._get_primitive_program(
+                    primitive, flags, ProgramFlags.NONE
+                )
+                program._bind()
+
+                # Set the camera uniforms
+                program.set_uniform('V', V)
+                program.set_uniform('P', P)
+                program.set_uniform(
+                    'cam_pos', scene.get_pose(scene.main_camera_node)[:3,3]
+                )
+
+                # Finally, bind and draw the primitive
+                self._bind_and_draw_primitive(
+                    primitive=primitive,
+                    pose=scene.get_pose(node),
+                    program=program,
+                    flags=RenderFlags.DEPTH_ONLY
+                )
+                self._reset_active_textures()
+
+        # Unbind the shader and flush the output
+        if program is not None:
+            program._unbind()
+        glFlush()
+
+    def _normals_pass(self, scene, flags):
+        # Set up viewport for render
+        self._configure_forward_pass_viewport(flags)
+        program = None
+
+        # Set up camera matrices
+        V, P = self._get_camera_matrices(scene)
+
+        # Now, render each object in sorted order
+        for node in self._sorted_mesh_nodes(scene):
+            mesh = node.mesh
+
+            # Skip the mesh if it's not visible
+            if not mesh.is_visible:
+                continue
+
+            for primitive in mesh.primitives:
+
+                # Skip objects that don't have normals
+                if not primitive.buf_flags & BufFlags.NORMAL:
+                    continue
+
+                # First, get and bind the appropriate program
+                pf = ProgramFlags.NONE
+                if flags & RenderFlags.VERTEX_NORMALS:
+                    pf = pf | ProgramFlags.VERTEX_NORMALS
+                if flags & RenderFlags.FACE_NORMALS:
+                    pf = pf | ProgramFlags.FACE_NORMALS
+                program = self._get_primitive_program(primitive, flags, pf)
+                program._bind()
+
+                # Set the camera uniforms
+                program.set_uniform('V', V)
+                program.set_uniform('P', P)
+                program.set_uniform('normal_magnitude', 0.05 * primitive.scale)
+                program.set_uniform(
+                    'normal_color', np.array([0.1, 0.1, 1.0, 1.0])
+                )
+
+                # Finally, bind and draw the primitive
+                self._bind_and_draw_primitive(
+                    primitive=primitive,
+                    pose=scene.get_pose(node),
+                    program=program,
+                    flags=RenderFlags.DEPTH_ONLY
+                )
+                self._reset_active_textures()
+
+        # Unbind the shader and flush the output
+        if program is not None:
+            program._unbind()
+        glFlush()
+
+    ###########################################################################
+    # Handlers for binding uniforms and drawing primitives
+    ###########################################################################
+
+    def _bind_and_draw_primitive(self, primitive, pose, program, flags):
+        # Set model pose matrix
+        program.set_uniform('M', pose)
+
+        # Bind mesh buffers
+        primitive._bind()
+
+        # Bind mesh material
+        if not (flags & RenderFlags.DEPTH_ONLY or flags & RenderFlags.SEG):
+            material = primitive.material
+
+            # Bind textures
+            tf = material.tex_flags
+            if tf & TexFlags.NORMAL:
+                self._bind_texture(material.normalTexture,
+                                   'material.normal_texture', program)
+            if tf & TexFlags.OCCLUSION:
+                self._bind_texture(material.occlusionTexture,
+                                   'material.occlusion_texture', program)
+            if tf & TexFlags.EMISSIVE:
+                self._bind_texture(material.emissiveTexture,
+                                   'material.emissive_texture', program)
+            if tf & TexFlags.BASE_COLOR:
+                self._bind_texture(material.baseColorTexture,
+                                   'material.base_color_texture', program)
+            if tf & TexFlags.METALLIC_ROUGHNESS:
+                self._bind_texture(material.metallicRoughnessTexture,
+                                   'material.metallic_roughness_texture',
+                                   program)
+            if tf & TexFlags.DIFFUSE:
+                self._bind_texture(material.diffuseTexture,
+                                   'material.diffuse_texture', program)
+            if tf & TexFlags.SPECULAR_GLOSSINESS:
+                self._bind_texture(material.specularGlossinessTexture,
+                                   'material.specular_glossiness_texture',
+                                   program)
+
+            # Bind other uniforms
+            b = 'material.{}'
+            program.set_uniform(b.format('emissive_factor'),
+                                material.emissiveFactor)
+            if isinstance(material, MetallicRoughnessMaterial):
+                program.set_uniform(b.format('base_color_factor'),
+                                    material.baseColorFactor)
+                program.set_uniform(b.format('metallic_factor'),
+                                    material.metallicFactor)
+                program.set_uniform(b.format('roughness_factor'),
+                                    material.roughnessFactor)
+            elif isinstance(material, SpecularGlossinessMaterial):
+                program.set_uniform(b.format('diffuse_factor'),
+                                    material.diffuseFactor)
+                program.set_uniform(b.format('specular_factor'),
+                                    material.specularFactor)
+                program.set_uniform(b.format('glossiness_factor'),
+                                    material.glossinessFactor)
+
+            # Set blending options
+            if material.alphaMode == 'BLEND':
+                glEnable(GL_BLEND)
+                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+            else:
+                glEnable(GL_BLEND)
+                glBlendFunc(GL_ONE, GL_ZERO)
+
+            # Set wireframe mode
+            wf = material.wireframe
+            if flags & RenderFlags.FLIP_WIREFRAME:
+                wf = not wf
+            if (flags & RenderFlags.ALL_WIREFRAME) or wf:
+                glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+            else:
+                glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+
+            # Set culling mode
+            if material.doubleSided or flags & RenderFlags.SKIP_CULL_FACES:
+                glDisable(GL_CULL_FACE)
+            else:
+                glEnable(GL_CULL_FACE)
+                glCullFace(GL_BACK)
+        else:
+            glEnable(GL_CULL_FACE)
+            glEnable(GL_BLEND)
+            glCullFace(GL_BACK)
+            glBlendFunc(GL_ONE, GL_ZERO)
+            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+
+        # Set point size if needed
+        glDisable(GL_PROGRAM_POINT_SIZE)
+        if primitive.mode == GLTF.POINTS:
+            glEnable(GL_PROGRAM_POINT_SIZE)
+            glPointSize(self.point_size)
+
+        # Render mesh
+        n_instances = 1
+        if primitive.poses is not None:
+            n_instances = len(primitive.poses)
+
+        if primitive.indices is not None:
+            glDrawElementsInstanced(
+                primitive.mode, primitive.indices.size, GL_UNSIGNED_INT,
+                ctypes.c_void_p(0), n_instances
+            )
+        else:
+            glDrawArraysInstanced(
+                primitive.mode, 0, len(primitive.positions), n_instances
+            )
+
+        # Unbind mesh buffers
+        primitive._unbind()
+
+    def _bind_lighting(self, scene, program, node, flags):
+        """Bind all lighting uniform values for a scene.
+        """
+        max_n_lights = self._compute_max_n_lights(flags)
+
+        n_d = min(len(scene.directional_light_nodes), max_n_lights[0])
+        n_s = min(len(scene.spot_light_nodes), max_n_lights[1])
+        n_p = min(len(scene.point_light_nodes), max_n_lights[2])
+        program.set_uniform('ambient_light', scene.ambient_light)
+        program.set_uniform('n_directional_lights', n_d)
+        program.set_uniform('n_spot_lights', n_s)
+        program.set_uniform('n_point_lights', n_p)
+        plc = 0
+        slc = 0
+        dlc = 0
+
+        light_nodes = scene.light_nodes
+        if (len(scene.directional_light_nodes) > max_n_lights[0] or
+                len(scene.spot_light_nodes) > max_n_lights[1] or
+                len(scene.point_light_nodes) > max_n_lights[2]):
+            light_nodes = self._sorted_nodes_by_distance(
+                scene, scene.light_nodes, node
+            )
+
+        for n in light_nodes:
+            light = n.light
+            pose = scene.get_pose(n)
+            position = pose[:3,3]
+            direction = -pose[:3,2]
+
+            if isinstance(light, PointLight):
+                if plc == max_n_lights[2]:
+                    continue
+                b = 'point_lights[{}].'.format(plc)
+                plc += 1
+                shadow = bool(flags & RenderFlags.SHADOWS_POINT)
+                program.set_uniform(b + 'position', position)
+            elif isinstance(light, SpotLight):
+                if slc == max_n_lights[1]:
+                    continue
+                b = 'spot_lights[{}].'.format(slc)
+                slc += 1
+                shadow = bool(flags & RenderFlags.SHADOWS_SPOT)
+                las = 1.0 / max(0.001, np.cos(light.innerConeAngle) -
+                                np.cos(light.outerConeAngle))
+                lao = -np.cos(light.outerConeAngle) * las
+                program.set_uniform(b + 'direction', direction)
+                program.set_uniform(b + 'position', position)
+                program.set_uniform(b + 'light_angle_scale', las)
+                program.set_uniform(b + 'light_angle_offset', lao)
+            else:
+                if dlc == max_n_lights[0]:
+                    continue
+                b = 'directional_lights[{}].'.format(dlc)
+                dlc += 1
+                shadow = bool(flags & RenderFlags.SHADOWS_DIRECTIONAL)
+                program.set_uniform(b + 'direction', direction)
+
+            program.set_uniform(b + 'color', light.color)
+            program.set_uniform(b + 'intensity', light.intensity)
+            # if light.range is not None:
+            #     program.set_uniform(b + 'range', light.range)
+            # else:
+            #     program.set_uniform(b + 'range', 0)
+
+            if shadow:
+                self._bind_texture(light.shadow_texture,
+                                   b + 'shadow_map', program)
+                if not isinstance(light, PointLight):
+                    V, P = self._get_light_cam_matrices(scene, n, flags)
+                    program.set_uniform(b + 'light_matrix', P.dot(V))
+                else:
+                    raise NotImplementedError(
+                        'Point light shadows not implemented'
+                    )
+
+    def _sorted_mesh_nodes(self, scene):
+        cam_loc = scene.get_pose(scene.main_camera_node)[:3,3]
+        solid_nodes = []
+        trans_nodes = []
+        for node in scene.mesh_nodes:
+            mesh = node.mesh
+            if mesh.is_transparent:
+                trans_nodes.append(node)
+            else:
+                solid_nodes.append(node)
+
+        # TODO BETTER SORTING METHOD
+        trans_nodes.sort(
+            key=lambda n: -np.linalg.norm(scene.get_pose(n)[:3,3] - cam_loc)
+        )
+        solid_nodes.sort(
+            key=lambda n: -np.linalg.norm(scene.get_pose(n)[:3,3] - cam_loc)
+        )
+
+        return solid_nodes + trans_nodes
+
+    def _sorted_nodes_by_distance(self, scene, nodes, compare_node):
+        nodes = list(nodes)
+        compare_posn = scene.get_pose(compare_node)[:3,3]
+        nodes.sort(key=lambda n: np.linalg.norm(
+            scene.get_pose(n)[:3,3] - compare_posn)
+        )
+        return nodes
+
+    ###########################################################################
+    # Context Management
+    ###########################################################################
+
+    def _update_context(self, scene, flags):
+
+        # Update meshes
+        scene_meshes = scene.meshes
+
+        # Add new meshes to context
+        for mesh in scene_meshes - self._meshes:
+            for p in mesh.primitives:
+                p._add_to_context()
+
+        # Remove old meshes from context
+        for mesh in self._meshes - scene_meshes:
+            for p in mesh.primitives:
+                p.delete()
+
+        self._meshes = scene_meshes.copy()
+
+        # Update mesh textures
+        mesh_textures = set()
+        for m in scene_meshes:
+            for p in m.primitives:
+                mesh_textures |= p.material.textures
+
+        # Add new textures to context
+        for texture in mesh_textures - self._mesh_textures:
+            texture._add_to_context()
+
+        # Remove old textures from context
+        for texture in self._mesh_textures - mesh_textures:
+            texture.delete()
+
+        self._mesh_textures = mesh_textures.copy()
+
+        shadow_textures = set()
+        for l in scene.lights:
+            # Create if needed
+            active = False
+            if (isinstance(l, DirectionalLight) and
+                    flags & RenderFlags.SHADOWS_DIRECTIONAL):
+                active = True
+            elif (isinstance(l, PointLight) and
+                    flags & RenderFlags.SHADOWS_POINT):
+                active = True
+            elif isinstance(l, SpotLight) and flags & RenderFlags.SHADOWS_SPOT:
+                active = True
+
+            if active and l.shadow_texture is None:
+                l._generate_shadow_texture()
+            if l.shadow_texture is not None:
+                shadow_textures.add(l.shadow_texture)
+
+        # Add new textures to context
+        for texture in shadow_textures - self._shadow_textures:
+            texture._add_to_context()
+
+        # Remove old textures from context
+        for texture in self._shadow_textures - shadow_textures:
+            texture.delete()
+
+        self._shadow_textures = shadow_textures.copy()
+
+    ###########################################################################
+    # Texture Management
+    ###########################################################################
+
+    def _bind_texture(self, texture, uniform_name, program):
+        """Bind a texture to an active texture unit and return
+        the texture unit index that was used.
+        """
+        tex_id = self._get_next_active_texture()
+        glActiveTexture(GL_TEXTURE0 + tex_id)
+        texture._bind()
+        program.set_uniform(uniform_name, tex_id)
+
+    def _get_next_active_texture(self):
+        val = self._texture_alloc_idx
+        self._texture_alloc_idx += 1
+        return val
+
+    def _reset_active_textures(self):
+        self._texture_alloc_idx = 0
+
+    ###########################################################################
+    # Camera Matrix Management
+    ###########################################################################
+
+    def _get_camera_matrices(self, scene):
+        main_camera_node = scene.main_camera_node
+        if main_camera_node is None:
+            raise ValueError('Cannot render scene without a camera')
+        P = main_camera_node.camera.get_projection_matrix(
+            width=self.viewport_width, height=self.viewport_height
+        )
+        pose = scene.get_pose(main_camera_node)
+        V = np.linalg.inv(pose)  # V maps from world to camera
+        return V, P
+
+    def _get_light_cam_matrices(self, scene, light_node, flags):
+        light = light_node.light
+        pose = scene.get_pose(light_node).copy()
+        s = scene.scale
+        camera = light._get_shadow_camera(s)
+        P = camera.get_projection_matrix()
+        if isinstance(light, DirectionalLight):
+            direction = -pose[:3,2]
+            c = scene.centroid
+            loc = c - direction * s
+            pose[:3,3] = loc
+        V = np.linalg.inv(pose)  # V maps from world to camera
+        return V, P
+
+    ###########################################################################
+    # Shader Program Management
+    ###########################################################################
+
+    def _get_text_program(self):
+        program = self._program_cache.get_program(
+            vertex_shader='text.vert',
+            fragment_shader='text.frag'
+        )
+
+        if not program._in_context():
+            program._add_to_context()
+
+        return program
+
+    def _compute_max_n_lights(self, flags):
+        max_n_lights = [MAX_N_LIGHTS, MAX_N_LIGHTS, MAX_N_LIGHTS]
+        n_tex_units = glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS)
+
+        # Reserved texture units: 6
+        #   Normal Map
+        #   Occlusion Map
+        #   Emissive Map
+        #   Base Color or Diffuse Map
+        #   MR or SG Map
+        #   Environment cubemap
+
+        n_reserved_textures = 6
+        n_available_textures = n_tex_units - n_reserved_textures
+
+        # Distribute textures evenly among lights with shadows, with
+        # a preference for directional lights
+        n_shadow_types = 0
+        if flags & RenderFlags.SHADOWS_DIRECTIONAL:
+            n_shadow_types += 1
+        if flags & RenderFlags.SHADOWS_SPOT:
+            n_shadow_types += 1
+        if flags & RenderFlags.SHADOWS_POINT:
+            n_shadow_types += 1
+
+        if n_shadow_types > 0:
+            tex_per_light = n_available_textures // n_shadow_types
+
+            if flags & RenderFlags.SHADOWS_DIRECTIONAL:
+                max_n_lights[0] = (
+                    tex_per_light +
+                    (n_available_textures - tex_per_light * n_shadow_types)
+                )
+            if flags & RenderFlags.SHADOWS_SPOT:
+                max_n_lights[1] = tex_per_light
+            if flags & RenderFlags.SHADOWS_POINT:
+                max_n_lights[2] = tex_per_light
+
+        return max_n_lights
+
+    def _get_primitive_program(self, primitive, flags, program_flags):
+        vertex_shader = None
+        fragment_shader = None
+        geometry_shader = None
+        defines = {}
+
+        if (bool(program_flags & ProgramFlags.USE_MATERIAL) and
+                not flags & RenderFlags.DEPTH_ONLY and
+                not flags & RenderFlags.FLAT and
+                not flags & RenderFlags.SEG):
+            vertex_shader = 'mesh.vert'
+            fragment_shader = 'mesh.frag'
+        elif bool(program_flags & (ProgramFlags.VERTEX_NORMALS |
+                                   ProgramFlags.FACE_NORMALS)):
+            vertex_shader = 'vertex_normals.vert'
+            if primitive.mode == GLTF.POINTS:
+                geometry_shader = 'vertex_normals_pc.geom'
+            else:
+                geometry_shader = 'vertex_normals.geom'
+            fragment_shader = 'vertex_normals.frag'
+        elif flags & RenderFlags.FLAT:
+            vertex_shader = 'flat.vert'
+            fragment_shader = 'flat.frag'
+        elif flags & RenderFlags.SEG:
+            vertex_shader = 'segmentation.vert'
+            fragment_shader = 'segmentation.frag'
+        else:
+            vertex_shader = 'mesh_depth.vert'
+            fragment_shader = 'mesh_depth.frag'
+
+        # Set up vertex buffer DEFINES
+        bf = primitive.buf_flags
+        buf_idx = 1
+        if bf & BufFlags.NORMAL:
+            defines['NORMAL_LOC'] = buf_idx
+            buf_idx += 1
+        if bf & BufFlags.TANGENT:
+            defines['TANGENT_LOC'] = buf_idx
+            buf_idx += 1
+        if bf & BufFlags.TEXCOORD_0:
+            defines['TEXCOORD_0_LOC'] = buf_idx
+            buf_idx += 1
+        if bf & BufFlags.TEXCOORD_1:
+            defines['TEXCOORD_1_LOC'] = buf_idx
+            buf_idx += 1
+        if bf & BufFlags.COLOR_0:
+            defines['COLOR_0_LOC'] = buf_idx
+            buf_idx += 1
+        if bf & BufFlags.JOINTS_0:
+            defines['JOINTS_0_LOC'] = buf_idx
+            buf_idx += 1
+        if bf & BufFlags.WEIGHTS_0:
+            defines['WEIGHTS_0_LOC'] = buf_idx
+            buf_idx += 1
+        defines['INST_M_LOC'] = buf_idx
+
+        # Set up shadow mapping defines
+        if flags & RenderFlags.SHADOWS_DIRECTIONAL:
+            defines['DIRECTIONAL_LIGHT_SHADOWS'] = 1
+        if flags & RenderFlags.SHADOWS_SPOT:
+            defines['SPOT_LIGHT_SHADOWS'] = 1
+        if flags & RenderFlags.SHADOWS_POINT:
+            defines['POINT_LIGHT_SHADOWS'] = 1
+        max_n_lights = self._compute_max_n_lights(flags)
+        defines['MAX_DIRECTIONAL_LIGHTS'] = max_n_lights[0]
+        defines['MAX_SPOT_LIGHTS'] = max_n_lights[1]
+        defines['MAX_POINT_LIGHTS'] = max_n_lights[2]
+
+        # Set up vertex normal defines
+        if program_flags & ProgramFlags.VERTEX_NORMALS:
+            defines['VERTEX_NORMALS'] = 1
+        if program_flags & ProgramFlags.FACE_NORMALS:
+            defines['FACE_NORMALS'] = 1
+
+        # Set up material texture defines
+        if bool(program_flags & ProgramFlags.USE_MATERIAL):
+            tf = primitive.material.tex_flags
+            if tf & TexFlags.NORMAL:
+                defines['HAS_NORMAL_TEX'] = 1
+            if tf & TexFlags.OCCLUSION:
+                defines['HAS_OCCLUSION_TEX'] = 1
+            if tf & TexFlags.EMISSIVE:
+                defines['HAS_EMISSIVE_TEX'] = 1
+            if tf & TexFlags.BASE_COLOR:
+                defines['HAS_BASE_COLOR_TEX'] = 1
+            if tf & TexFlags.METALLIC_ROUGHNESS:
+                defines['HAS_METALLIC_ROUGHNESS_TEX'] = 1
+            if tf & TexFlags.DIFFUSE:
+                defines['HAS_DIFFUSE_TEX'] = 1
+            if tf & TexFlags.SPECULAR_GLOSSINESS:
+                defines['HAS_SPECULAR_GLOSSINESS_TEX'] = 1
+            if isinstance(primitive.material, MetallicRoughnessMaterial):
+                defines['USE_METALLIC_MATERIAL'] = 1
+            elif isinstance(primitive.material, SpecularGlossinessMaterial):
+                defines['USE_GLOSSY_MATERIAL'] = 1
+
+        program = self._program_cache.get_program(
+            vertex_shader=vertex_shader,
+            fragment_shader=fragment_shader,
+            geometry_shader=geometry_shader,
+            defines=defines
+        )
+
+        if not program._in_context():
+            program._add_to_context()
+
+        return program
+
+    ###########################################################################
+    # Viewport Management
+    ###########################################################################
+
+    def _configure_forward_pass_viewport(self, flags):
+
+        # If using offscreen render, bind main framebuffer
+        if flags & RenderFlags.OFFSCREEN:
+            self._configure_main_framebuffer()
+            glBindFramebuffer(GL_DRAW_FRAMEBUFFER, self._main_fb_ms)
+        else:
+            glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0)
+
+        glViewport(0, 0, self.viewport_width, self.viewport_height)
+        glEnable(GL_DEPTH_TEST)
+        glDepthMask(GL_TRUE)
+        glDepthFunc(GL_LESS)
+        glDepthRange(0.0, 1.0)
+
+    def _configure_shadow_mapping_viewport(self, light, flags):
+        self._configure_shadow_framebuffer()
+        glBindFramebuffer(GL_FRAMEBUFFER, self._shadow_fb)
+        light.shadow_texture._bind()
+        light.shadow_texture._bind_as_depth_attachment()
+        glActiveTexture(GL_TEXTURE0)
+        light.shadow_texture._bind()
+        glDrawBuffer(GL_NONE)
+        glReadBuffer(GL_NONE)
+
+        glClear(GL_DEPTH_BUFFER_BIT)
+        glViewport(0, 0, SHADOW_TEX_SZ, SHADOW_TEX_SZ)
+        glEnable(GL_DEPTH_TEST)
+        glDepthMask(GL_TRUE)
+        glDepthFunc(GL_LESS)
+        glDepthRange(0.0, 1.0)
+        glDisable(GL_CULL_FACE)
+        glDisable(GL_BLEND)
+
+    ###########################################################################
+    # Framebuffer Management
+    ###########################################################################
+
+    def _configure_shadow_framebuffer(self):
+        if self._shadow_fb is None:
+            self._shadow_fb = glGenFramebuffers(1)
+
+    def _delete_shadow_framebuffer(self):
+        if self._shadow_fb is not None:
+            glDeleteFramebuffers(1, [self._shadow_fb])
+
+    def _configure_main_framebuffer(self):
+        # If mismatch with prior framebuffer, delete it
+        if (self._main_fb is not None and
+                self.viewport_width != self._main_fb_dims[0] or
+                self.viewport_height != self._main_fb_dims[1]):
+            self._delete_main_framebuffer()
+
+        # If framebuffer doesn't exist, create it
+        if self._main_fb is None:
+            # Generate standard buffer
+            self._main_cb, self._main_db = glGenRenderbuffers(2)
+
+            glBindRenderbuffer(GL_RENDERBUFFER, self._main_cb)
+            glRenderbufferStorage(
+                GL_RENDERBUFFER, GL_RGBA,
+                self.viewport_width, self.viewport_height
+            )
+
+            glBindRenderbuffer(GL_RENDERBUFFER, self._main_db)
+            glRenderbufferStorage(
+                GL_RENDERBUFFER, GL_DEPTH_COMPONENT24,
+                self.viewport_width, self.viewport_height
+            )
+
+            self._main_fb = glGenFramebuffers(1)
+            glBindFramebuffer(GL_DRAW_FRAMEBUFFER, self._main_fb)
+            glFramebufferRenderbuffer(
+                GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                GL_RENDERBUFFER, self._main_cb
+            )
+            glFramebufferRenderbuffer(
+                GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                GL_RENDERBUFFER, self._main_db
+            )
+
+            # Generate multisample buffer
+            self._main_cb_ms, self._main_db_ms = glGenRenderbuffers(2)
+            glBindRenderbuffer(GL_RENDERBUFFER, self._main_cb_ms)
+            # glRenderbufferStorageMultisample(
+            #     GL_RENDERBUFFER, 4, GL_RGBA,
+            #     self.viewport_width, self.viewport_height
+            # )
+            # glBindRenderbuffer(GL_RENDERBUFFER, self._main_db_ms)
+            # glRenderbufferStorageMultisample(
+            #     GL_RENDERBUFFER, 4, GL_DEPTH_COMPONENT24,
+            #     self.viewport_width, self.viewport_height
+            # )
+            # 增加这一行
+            num_samples = min(glGetIntegerv(GL_MAX_SAMPLES), 4) # No more than GL_MAX_SAMPLES
+
+            # 其实就是把 4 替换成 num_samples，其余不变
+            glRenderbufferStorageMultisample(GL_RENDERBUFFER, num_samples, GL_RGBA, self.viewport_width, self.viewport_height)
+
+            glBindRenderbuffer(GL_RENDERBUFFER, self._main_db_ms) # 这行不变
+
+            # 这一行也是将 4 替换成 num_samples
+            glRenderbufferStorageMultisample(GL_RENDERBUFFER, num_samples, GL_DEPTH_COMPONENT24, self.viewport_width, self.viewport_height)
+            
+            self._main_fb_ms = glGenFramebuffers(1)
+            glBindFramebuffer(GL_DRAW_FRAMEBUFFER, self._main_fb_ms)
+            glFramebufferRenderbuffer(
+                GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                GL_RENDERBUFFER, self._main_cb_ms
+            )
+            glFramebufferRenderbuffer(
+                GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                GL_RENDERBUFFER, self._main_db_ms
+            )
+
+            self._main_fb_dims = (self.viewport_width, self.viewport_height)
+
+    def _delete_main_framebuffer(self):
+        if self._main_fb is not None:
+            glDeleteFramebuffers(2, [self._main_fb, self._main_fb_ms])
+        if self._main_cb is not None:
+            glDeleteRenderbuffers(2, [self._main_cb, self._main_cb_ms])
+        if self._main_db is not None:
+            glDeleteRenderbuffers(2, [self._main_db, self._main_db_ms])
+
+        self._main_fb = None
+        self._main_cb = None
+        self._main_db = None
+        self._main_fb_ms = None
+        self._main_cb_ms = None
+        self._main_db_ms = None
+        self._main_fb_dims = (None, None)
+
+    def _read_main_framebuffer(self, scene, flags):
+        width, height = self._main_fb_dims[0], self._main_fb_dims[1]
+
+        # Bind framebuffer and blit buffers
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, self._main_fb_ms)
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, self._main_fb)
+        glBlitFramebuffer(
+            0, 0, width, height, 0, 0, width, height,
+            GL_COLOR_BUFFER_BIT, GL_LINEAR
+        )
+        glBlitFramebuffer(
+            0, 0, width, height, 0, 0, width, height,
+            GL_DEPTH_BUFFER_BIT, GL_NEAREST
+        )
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, self._main_fb)
+
+        # Read depth
+        depth_buf = glReadPixels(
+            0, 0, width, height, GL_DEPTH_COMPONENT, GL_FLOAT
+        )
+        depth_im = np.frombuffer(depth_buf, dtype=np.float32)
+        depth_im = depth_im.reshape((height, width))
+        depth_im = np.flip(depth_im, axis=0)
+        inf_inds = (depth_im == 1.0)
+        depth_im = 2.0 * depth_im - 1.0
+        z_near = scene.main_camera_node.camera.znear
+        z_far = scene.main_camera_node.camera.zfar
+        noninf = np.logical_not(inf_inds)
+        if z_far is None:
+            depth_im[noninf] = 2 * z_near / (1.0 - depth_im[noninf])
+        else:
+            depth_im[noninf] = ((2.0 * z_near * z_far) /
+                                (z_far + z_near - depth_im[noninf] *
+                                (z_far - z_near)))
+        depth_im[inf_inds] = 0.0
+
+        # Resize for macos if needed
+        if sys.platform == 'darwin':
+            depth_im = self._resize_image(depth_im)
+
+        if flags & RenderFlags.DEPTH_ONLY:
+            return depth_im
+
+        # Read color
+        if flags & RenderFlags.RGBA:
+            color_buf = glReadPixels(
+                0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE
+            )
+            color_im = np.frombuffer(color_buf, dtype=np.uint8)
+            color_im = color_im.reshape((height, width, 4))
+        else:
+            color_buf = glReadPixels(
+                0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE
+            )
+            color_im = np.frombuffer(color_buf, dtype=np.uint8)
+            color_im = color_im.reshape((height, width, 3))
+        color_im = np.flip(color_im, axis=0)
+
+        # Resize for macos if needed
+        if sys.platform == 'darwin':
+            color_im = self._resize_image(color_im, True)
+
+        return color_im, depth_im
+
+    def _resize_image(self, value, antialias=False):
+        """If needed, rescale the render for MacOS."""
+        img = PIL.Image.fromarray(value)
+        resample = PIL.Image.NEAREST
+        if antialias:
+            resample = PIL.Image.BILINEAR
+        size = (self.viewport_width // self.dpscale,
+                self.viewport_height // self.dpscale)
+        img = img.resize(size, resample=resample)
+        return np.array(img)
+
+    ###########################################################################
+    # Shadowmap Debugging
+    ###########################################################################
+
+    def _forward_pass_no_reset(self, scene, flags):
+        # Set up camera matrices
+        V, P = self._get_camera_matrices(scene)
+
+        # Now, render each object in sorted order
+        for node in self._sorted_mesh_nodes(scene):
+            mesh = node.mesh
+
+            # Skip the mesh if it's not visible
+            if not mesh.is_visible:
+                continue
+
+            for primitive in mesh.primitives:
+
+                # First, get and bind the appropriate program
+                program = self._get_primitive_program(
+                    primitive, flags, ProgramFlags.USE_MATERIAL
+                )
+                program._bind()
+
+                # Set the camera uniforms
+                program.set_uniform('V', V)
+                program.set_uniform('P', P)
+                program.set_uniform(
+                    'cam_pos', scene.get_pose(scene.main_camera_node)[:3,3]
+                )
+
+                # Next, bind the lighting
+                if not flags & RenderFlags.DEPTH_ONLY and not flags & RenderFlags.FLAT:
+                    self._bind_lighting(scene, program, node, flags)
+
+                # Finally, bind and draw the primitive
+                self._bind_and_draw_primitive(
+                    primitive=primitive,
+                    pose=scene.get_pose(node),
+                    program=program,
+                    flags=flags
+                )
+                self._reset_active_textures()
+
+        # Unbind the shader and flush the output
+        if program is not None:
+            program._unbind()
+        glFlush()
+
+    def _render_light_shadowmaps(self, scene, light_nodes, flags, tile=False):
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0)
+        glClearColor(*scene.bg_color)
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+        glEnable(GL_DEPTH_TEST)
+        glDepthMask(GL_TRUE)
+        glDepthFunc(GL_LESS)
+        glDepthRange(0.0, 1.0)
+
+        w = self.viewport_width
+        h = self.viewport_height
+
+        num_nodes = len(light_nodes)
+        viewport_dims = {
+            (0, 2): [0, h // 2, w // 2, h],
+            (1, 2): [w // 2, h // 2, w, h],
+            (0, 3): [0, h // 2, w // 2, h],
+            (1, 3): [w // 2, h // 2, w, h],
+            (2, 3): [0, 0, w // 2, h // 2],
+            (0, 4): [0, h // 2, w // 2, h],
+            (1, 4): [w // 2, h // 2, w, h],
+            (2, 4): [0, 0, w // 2, h // 2],
+            (3, 4): [w // 2, 0, w, h // 2]
+        }
+
+        if tile:
+            for i, ln in enumerate(light_nodes):
+                light = ln.light
+
+                if light.shadow_texture is None:
+                    raise ValueError('Light does not have a shadow texture')
+
+                glViewport(*viewport_dims[(i, num_nodes + 1)])
+
+                program = self._get_debug_quad_program()
+                program._bind()
+                self._bind_texture(light.shadow_texture, 'depthMap', program)
+                self._render_debug_quad()
+                self._reset_active_textures()
+                glFlush()
+            i += 1
+            glViewport(*viewport_dims[(i, num_nodes + 1)])
+            self._forward_pass_no_reset(scene, flags)
+        else:
+            for i, ln in enumerate(light_nodes):
+                light = ln.light
+
+                if light.shadow_texture is None:
+                    raise ValueError('Light does not have a shadow texture')
+
+                glViewport(0, 0, self.viewport_width, self.viewport_height)
+
+                program = self._get_debug_quad_program()
+                program._bind()
+                self._bind_texture(light.shadow_texture, 'depthMap', program)
+                self._render_debug_quad()
+                self._reset_active_textures()
+                glFlush()
+                return
+
+    def _get_debug_quad_program(self):
+        program = self._program_cache.get_program(
+            vertex_shader='debug_quad.vert',
+            fragment_shader='debug_quad.frag'
+        )
+        if not program._in_context():
+            program._add_to_context()
+        return program
+
+    def _render_debug_quad(self):
+        x = glGenVertexArrays(1)
+        glBindVertexArray(x)
+        glDrawArrays(GL_TRIANGLES, 0, 6)
+        glBindVertexArray(0)
+        glDeleteVertexArrays(1, [x])