OpenGLContext 3.0.0a7__tar.gz → 3.0.0a8__tar.gz

{openglcontext-3.0.0a7 → openglcontext-3.0.0a8}/OpenGLContext/__init__.py

@@ -32,7 +32,7 @@ It is also the primary suite of test cases PyOpenGL is verified against.
 Documentation is under `docs/`, indexed by `docs/documentation.rst`.
 '''
 
-__version__ = "3.0.0a7"
+__version__ = "3.0.0a8"
 __author__ = "Michael Colin Fletcher"
 __license__ = "BSD-Style, see license.txt for details and exceptions"
 

{openglcontext-3.0.0a7 → openglcontext-3.0.0a8}/OpenGLContext/contextdefinition.py

@@ -217,6 +217,13 @@ class ContextDefinition( node.Node ):
     #: (env: OPENGLCONTEXT_SHADOW_DISTANCE).
     shadowDistance = field.newField( "shadowDistance", "SFFloat", 1,
                                      lambda: float(renderoptions.env_number('OPENGLCONTEXT_SHADOW_DISTANCE', 0.0)))
+    #: Frames between draws of each cascade beyond the nearest. 1 draws every cascade every
+    #: frame. Above 1, those cascades are fitted with room to spare, drawn in turn, and used
+    #: again while the slice of the view each serves stays inside it, which saves their depth
+    #: draws at the cost of a shadow that lags the camera by a frame or two at distance
+    #: (env: OPENGLCONTEXT_SHADOW_FAR_INTERVAL).
+    shadowFarInterval = field.newField( "shadowFarInterval", "SFInt32", 1,
+                                        lambda: int(renderoptions.env_number('OPENGLCONTEXT_SHADOW_FAR_INTERVAL', 1, integer=True)))
     #: Lights the shader will bind in one frame. Lower is faster in a scene
     #: with many lights; the shader's own ceiling still applies.
     #: (env: OPENGLCONTEXT_MAXIMUM_LIGHTS)
@@ -295,6 +302,16 @@ class ContextDefinition( node.Node ):
     planarReflections = field.newField( "planarReflections", "SFBool", 1,
                                         lambda: renderoptions.env_flag(
                                             'OPENGLCONTEXT_PLANAR_REFLECTIONS', True))
+    #: The optional parts the PBR program is compiled with: "all" (the default),
+    #: "none", or a comma-separated list of clearcoat, sheen, transmission,
+    #: extension-textures, texture-layers, planar-reflection, zone-probes and
+    #: volume-scatter (env: OPENGLCONTEXT_SHADER_FEATURES). Each part left out
+    #: lightens every pixel's shading; a scene that draws one it left out
+    #: draws without it. A window-creation setting: it takes effect when the
+    #: program is compiled, at the first frame. See OpenGLContext.passes.pbrpass.
+    shaderFeatures = field.newField( "shaderFeatures", "SFString", 1,
+                                     lambda: renderoptions.env_text(
+                                         'OPENGLCONTEXT_SHADER_FEATURES', 'all'))
     #: The most mirror views drawn in one frame. 0 takes the strategy's own:
     #: 16 where one submission reaches several views, 2 where each costs a
     #: draw of the scene (env: OPENGLCONTEXT_REFLECTION_VIEWS).
@@ -433,6 +450,8 @@ class ContextDefinition( node.Node ):
                            'maximum': 4, 'step': 1},
         'shadowDistance': {'label': 'Shadow distance', 'minimum': 0.0,
                            'maximum': 1000.0, 'step': 10.0},
+        'shadowFarInterval': {'label': 'Far shadow interval', 'minimum': 1,
+                              'maximum': 4, 'step': 1},
         'maximumLights': {'label': 'Lights', 'minimum': 0, 'maximum': 8,
                           'step': 1},
         'bloom': {'label': 'Bloom'},
@@ -499,7 +518,8 @@ class ContextDefinition( node.Node ):
     #: Fields a settings screen shows under "Rendering", in the order they
     #: should read: the expensive things first, the diagnostics last.
     RENDERING_FIELDS = (
-        'shadows', 'shadowsSoft', 'shadowCascades', 'shadowDistance', 'maximumLights',
+        'shadows', 'shadowsSoft', 'shadowCascades', 'shadowDistance', 'shadowFarInterval',
+        'maximumLights',
         'bloom', 'toneMapping', 'exposure', 'colorSpace', 'shading',
         'orderIndependentTransparency', 'primitiveQuality', 'textureQuality', 'ibl', 'iblIntensity', 'iblStudioFill', 'transmission', 'planarReflections',
         'reflectionViews', 'reflectionBounces', 'zoneCaptureFaces', 'instancing',

{openglcontext-3.0.0a7 → openglcontext-3.0.0a8}/OpenGLContext/frustum.py

@@ -61,7 +61,8 @@ def boxes_outside(centres: Any, halves: Any, matrices: Any, planes: Any) -> Any:
     Box ``i`` is ``centres[i]`` plus or minus ``halves[i]`` along each axis of
     its own space, placed by the row-vector ``matrices[i]`` (a point ``p``
     lands at ``p @ M``). ``centres`` and ``halves`` may be one ``(3,)`` box for
-    every matrix. ``planes`` are ``(a, b, c, d)`` rows with the kept side where
+    every matrix. ``matrices`` of None says the boxes are already in the space
+    of the planes. ``planes`` are ``(a, b, c, d)`` rows with the kept side where
     ``a*x + b*y + c*z + d >= 0``.
 
     The decision is the one testing the eight corners makes: a box is outside
@@ -70,6 +71,12 @@ def boxes_outside(centres: Any, halves: Any, matrices: Any, planes: Any) -> Any:
     where the corner furthest in front of it is the centre's distance plus
     the half-extents along the absolute normal.
     """
+    if matrices is None:
+        planes = np.asarray(planes, 'd')
+        normals = planes[:, :3].T
+        nearest = (np.reshape(centres, (-1, 3)) @ normals + planes[:, 3]
+                   + np.reshape(halves, (-1, 3)) @ np.abs(normals))
+        return (nearest < 0).any(axis=1)
     matrices = np.asarray(matrices)
     planes = np.asarray(planes, matrices.dtype)
     count = len(matrices)

{openglcontext-3.0.0a7 → openglcontext-3.0.0a8}/OpenGLContext/loaders/tiles3d/tileprocess.py

@@ -38,10 +38,14 @@ from collections.abc import Callable
 from importlib import import_module
 from typing import Any
 
-__all__ = ['TileProcesses', 'TileProcessError']
+__all__ = ['TileProcesses', 'TileProcessError', 'TileProcessInterrupted']
 
 #: Seconds a child has to start, import its factory and connect.
 START_TIMEOUT = 60.0
+#: Seconds a child whose connection broke is given to be seen ending.
+EXIT_GRACE = 0.5
+#: The status a child ends with when an interrupt stopped it: 128 and SIGINT's number.
+INTERRUPTED = 130
 _LENGTH = struct.Struct('!Q')
 
 
@@ -50,6 +54,11 @@ class TileProcessError(RuntimeError):
     traceback), or the child stopped."""
 
 
+class TileProcessInterrupted(TileProcessError):
+    """A child ended on an interrupt. A terminal's Ctrl-C reaches every process of its group, so
+    the application is ending too, and this is not a fault in the child."""
+
+
 def _send(sock: socket.socket, message: Any) -> None:
     data = pickle.dumps(message, protocol=pickle.HIGHEST_PROTOCOL)
     sock.sendall(_LENGTH.pack(len(data)))
@@ -130,6 +139,13 @@ class _Child:
             raise TileProcessError(result)
         return result
 
+    def interrupted(self) -> bool:
+        """Whether the child ended on an interrupt."""
+        try:
+            return self.process.wait(timeout=EXIT_GRACE) == INTERRUPTED
+        except subprocess.TimeoutExpired:
+            return False
+
     def kill(self) -> None:
         sock = getattr(self, 'sock', None)
         if sock is not None:
@@ -192,9 +208,12 @@ class TileProcesses:
                 self._children.append(child)
             return child.make(key)
         except (OSError, EOFError) as err:
+            interrupted = child is not None and child.interrupted()
             if child is not None:
                 self._forget(child)
                 child = None
+            if interrupted:
+                raise TileProcessInterrupted('a tile process was interrupted while making %r' % (key,)) from err
             raise TileProcessError('a tile process stopped while making %r: %s' % (key, err)) from err
         except TileProcessError:
             raise
@@ -221,9 +240,23 @@ def _close_weakly(ref: "weakref.ref[TileProcesses]") -> None:
         processes.close()
 
 
-def _serve() -> None:
+def _serve() -> int:
     """The child's end: connect, build the maker, and make a payload for each key until the
-    socket closes."""
+    socket closes. The exit status: :data:`INTERRUPTED` when an interrupt stopped it, else 0.
+
+    The parent closing the socket, or ending, is how a child is told to stop, so a connection
+    that fails is an ending and prints nothing.
+    """
+    try:
+        _converse()
+    except KeyboardInterrupt:
+        return INTERRUPTED
+    except (EOFError, OSError):
+        pass
+    return 0
+
+
+def _converse() -> None:
     host, port, token = sys.stdin.readline().split()
     sock = socket.create_connection((host, int(port)))
     _send(sock, token)
@@ -231,15 +264,12 @@ def _serve() -> None:
     sys.path.extend(p for p in paths if p not in sys.path)
     try:
         maker = _factory(factory)(*args)
-    except BaseException:
+    except Exception:
         _send(sock, traceback.format_exc())
         return
     _send(sock, None)
     while True:
-        try:
-            key = _receive(sock)
-        except (EOFError, OSError):
-            return
+        key = _receive(sock)
         if key is None:
             return
         try:
@@ -250,4 +280,4 @@ def _serve() -> None:
 
 
 if __name__ == '__main__':  # pragma: no cover - runs in the child
-    _serve()
+    sys.exit(_serve())

{openglcontext-3.0.0a7 → openglcontext-3.0.0a8}/OpenGLContext/noise.py

@@ -11,22 +11,35 @@ One unit of ``x``/``z`` is one feature of the coarsest octave, so a caller
 working in metres divides by the size it wants the features to be.
 """
 import numpy as np
+from numpy.typing import NDArray
 
-__all__ = ['fbm', 'ridged', 'smoothstep', 'value_noise']
+__all__ = ['FUSED_POINTS', 'fbm', 'ridged', 'smoothstep', 'value_noise']
 
 
-def _hash01(ix: np.ndarray, iz: np.ndarray, seed: int) -> np.ndarray:
+#: The offsets of a lattice cell's four corners from its lowest one, along the first axis of
+#: the arrays :func:`_hash01` is given.
+_CORNER_X = np.array([0, 1, 0, 1], dtype=np.int64)
+_CORNER_Z = np.array([0, 0, 1, 1], dtype=np.int64)
+
+
+#: How many points :func:`value_noise` hashes the four corners of together: more than this and the
+#: arrays outgrow the processor's cache, and one corner at a time is quicker.
+FUSED_POINTS = 2048
+
+
+def _hash01(ix: NDArray[np.int64], iz: NDArray[np.int64], seed: int) -> NDArray[np.float64]:
     """A value in [0, 1] for each integer lattice point, fixed by ``seed``.
 
-    The hash wraps in 64 bits, which is what mixes the bits; ``errstate`` keeps
-    NumPy from reporting the wrap when an input is a scalar.
+    ``ix`` and ``iz`` are integer arrays of at least one dimension. The hash wraps in 64
+    bits, which is what mixes the bits; NumPy reports a wrap in a scalar and not in an
+    array, so the arrays need no ``errstate``, which costs more than the hash.
     """
-    with np.errstate(over='ignore'):
-        h = (ix.astype(np.int64) * 374761393 + iz.astype(np.int64) * 668265263
-             + np.int64(seed) * 1013904223)
-        h = (h ^ (h >> np.int64(13))) * np.int64(1274126177)
-        h = h ^ (h >> np.int64(16))
-    return (h & np.int64(0xFFFFFF)).astype(np.float64) / float(0xFFFFFF)
+    h = ix * np.int64(374761393) + iz * np.int64(668265263) + np.int64(seed) * np.int64(1013904223)
+    h ^= h >> np.int64(13)
+    h *= np.int64(1274126177)
+    h ^= h >> np.int64(16)
+    h &= np.int64(0xFFFFFF)
+    return h.astype(np.float64) / float(0xFFFFFF)
 
 
 def smoothstep(t: np.ndarray) -> np.ndarray:
@@ -40,10 +53,17 @@ def value_noise(x: np.ndarray, z: np.ndarray, seed: int) -> np.ndarray:
     z0 = np.floor(z).astype(np.int64)
     fx = smoothstep(x - x0)
     fz = smoothstep(z - z0)
-    v00 = _hash01(x0, z0, seed)
-    v10 = _hash01(x0 + 1, z0, seed)
-    v01 = _hash01(x0, z0 + 1, seed)
-    v11 = _hash01(x0 + 1, z0 + 1, seed)
+    if x0.size <= FUSED_POINTS:
+        # The four corners of every cell, hashed as one array with the corner along the first
+        # axis: a handful of NumPy calls however few points there are.
+        where = (4,) + (1,) * x0.ndim
+        v00, v10, v01, v11 = _hash01(x0 + _CORNER_X.reshape(where), z0 + _CORNER_Z.reshape(where),
+                                     seed)
+    else:
+        v00 = _hash01(x0, z0, seed)
+        v10 = _hash01(x0 + 1, z0, seed)
+        v01 = _hash01(x0, z0 + 1, seed)
+        v11 = _hash01(x0 + 1, z0 + 1, seed)
     top = v00 * (1 - fx) + v10 * fx
     bot = v01 * (1 - fx) + v11 * fx
     return np.asarray(top * (1 - fz) + bot * fz)

{openglcontext-3.0.0a7 → openglcontext-3.0.0a8}/OpenGLContext/passes/_flat.py

@@ -1050,18 +1050,24 @@ class FlatPass( _FlatEffectsMixin, VolumePassMixin, LayeringPassMixin, Multiview
             self.matrix = mvmatrix
             self.renderPath = path
 
+            # A geometry that draws with a program of its own reads none of what is set
+            # here for this one: it is drawn where `self.matrix` says.
+            own = getattr(getattr(node, 'geometry', None), 'drawsOwnProgram', False)
+
             # Set matrices for this object (pass the program to avoid a per-draw
             # glGetIntegerv(GL_CURRENT_PROGRAM) round-trip).
-            shader.set_matrices(mvmatrix, self.projection, program=prog)
+            if not own:
+                shader.set_matrices(mvmatrix, self.projection, program=prog)
 
             # Set object ID for MRT selection buffer (stable per-path id; the
             # persistent map is maintained by _objectIdFor, not rebuilt here).
             # A non-pickable shape masks the id attachment instead, reading
             # through to whatever is behind it.
             masked = self._writeShapeId(shader, path, node, prog, id_map)
-            self.applyLightGrid(shader, node, tmatrix, bvolume, prog)
-            self.applyZones(shader, path, tmatrix, bvolume, prog)
-            self.applyPlanarReflection(shader, record, prog)
+            if not own:
+                self.applyLightGrid(shader, node, tmatrix, bvolume, prog)
+                self.applyZones(shader, path, tmatrix, bvolume, prog)
+                self.applyPlanarReflection(shader, record, prog)
 
             try:
                 node.Render(mode=self)
@@ -1321,7 +1327,31 @@ class FlatPass( _FlatEffectsMixin, VolumePassMixin, LayeringPassMixin, Multiview
         from OpenGLContext.passes import tonemapping  # noqa: PLC0415 contextdefinition imports it first
         if not self.toneMapped:
             return tonemapping.ENGINE
-        return tonemapping.display( self, getattr( self, 'scene', None ) )
+        state = self.frameState
+        if state is not None and state.display is not None:
+            held: 'tonemapping.Display' = state.display
+            return held
+        shown = tonemapping.display( self, getattr( self, 'scene', None ) )
+        if state is not None:
+            state.display = shown
+        return shown
+
+    def frameFog( self ) -> Any:
+        """The ``(mode, density, colour)`` the bound Fog fogs the frame's layers by, or None where
+        the scene binds none.
+
+        Worked out once for each layer drawn in a frame, since every layer that draws with its
+        own program asks and each is told the same.
+        """
+        state = self.frameState
+        layer = self.drawingLayer() if hasattr( self, 'drawingLayer' ) else None
+        if state is not None and layer in state.fogs:
+            return state.fogs[layer]
+        path = self.currentFog()
+        found = None if path is None else path[-1].fogParameters( path.transformMatrix() )
+        if state is not None:
+            state.fogs[layer] = found
+        return found
 
     def _weightingRuns( self, transparent: list ) -> list[tuple[bool, list]]:
         """``transparent``, farthest first, as runs of ``(weighted, records)``

{openglcontext-3.0.0a7 → openglcontext-3.0.0a8}/OpenGLContext/passes/framestate.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 
 import itertools
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 if TYPE_CHECKING:
     import numpy as np
@@ -31,13 +31,18 @@ _NUMBERS = itertools.count(1)
 class FrameState:
     """The state one frame shares among its stages."""
 
-    __slots__ = ('gathered', 'number', 'reach', 'refusesShare')
+    __slots__ = ('display', 'fogs', 'gathered', 'number', 'reach', 'refusesShare')
 
     def __init__(self) -> None:
         #: This frame's place in the process's frames, counting from 1.
         self.number = next(_NUMBERS)
         #: This frame's walk of the scene, once it has been made.
         self.gathered: Optional['GatheredPaths'] = None
+        #: The tone curve, colour space and exposure the frame is written with, once asked
+        #: for: every layer that draws with its own program asks, and each is told the same.
+        self.display: Any = None
+        #: The fog the frame's layers are drawn in, by the layer drawn, once asked for.
+        self.fogs: dict[Any, Any] = {}
         #: Where each shape of the walk is and how far it reaches, the world
         #: centres and radii of :func:`~OpenGLContext.passes.reflection.reach`,
         #: once a mirror view has asked.

{openglcontext-3.0.0a7 → openglcontext-3.0.0a8}/OpenGLContext/passes/pbrpass.py

@@ -446,27 +446,50 @@ PBR_OPTIONAL_FEATURES = ('CLEARCOAT', 'SHEEN', 'TRANSMISSION')
 def pbr_feature_defines(enabled: Optional[Any] = None) -> list:
     """USE_* defines choosing which optional lobes the PBR uber-shader includes.
 
-    FUTURE FEATURE -- not wired into compile() yet. Today the program is always
-    built with every lobe ON (see the USE_* fallbacks in pbr.frag), so the whole
-    scene keeps using one shader.
-
-    The intended use is a *per-platform / per-settings* decision made ONCE, at
-    program-compile time -- NOT per material. A constrained profile (say low-end
-    integrated graphics) could drop transmission + clearcoat to shrink the
-    uber-shader's register footprint for the entire scene, trading feature support
-    for occupancy. Because the choice is global, the scene still binds a single
-    program: this never causes per-material shader swapping.
-
     ``enabled`` is an iterable of names from PBR_OPTIONAL_FEATURES to keep; ``None``
-    keeps them all (the default program). Feed the result in at compile time::
-
-        preprocess_shader('pbr.frag', shadow_defines(...) + pbr_feature_defines(cfg))
+    keeps them all. The program is compiled with the lobes the application's
+    ``shaderFeatures`` names (:func:`shader_features`), once for the whole scene,
+    so the scene still binds a single program and never swaps shaders per material.
     """
     keep = set(PBR_OPTIONAL_FEATURES if enabled is None else enabled)
     return ['#define USE_%s %d' % (f, 1 if f in keep else 0)
             for f in PBR_OPTIONAL_FEATURES]
 
 
+#: The optional parts of the PBR program, by the names ``ContextDefinition.shaderFeatures``
+#: gives them. Each is compiled in where the driver has the texture units for it, and each
+#: adds to the registers every pixel of every draw is shaded with, so a program that never
+#: draws a mirror is faster without the mirror's code in it.
+#:
+#: ``clearcoat``, ``sheen`` and ``transmission`` are the lobes of
+#: :data:`PBR_OPTIONAL_FEATURES`; ``extension-textures`` the maps of the glTF material
+#: extensions (iridescence thickness, transmission and the like); ``texture-layers`` an
+#: X3D appearance's texture layers and projectors; ``planar-reflection`` the reflection
+#: atlas; ``zone-probes`` a zone's own environment probe; ``volume-scatter`` the volume
+#: scattering buffer.
+SHADER_FEATURES: tuple[str, ...] = (
+    'clearcoat', 'sheen', 'transmission', 'extension-textures', 'texture-layers',
+    'planar-reflection', 'zone-probes', 'volume-scatter')
+
+
+def shader_features(text: Optional[str]) -> Optional[frozenset[str]]:
+    """The features a ``shaderFeatures`` value names, or None for all of them.
+
+    ``text`` is ``all`` (or nothing), ``none`` or a comma-separated list of
+    :data:`SHADER_FEATURES`. A name that is not one is reported and left out.
+    """
+    words = [word.strip().lower() for word in (text or '').split(',') if word.strip()]
+    if not words or words == ['all']:
+        return None
+    if words == ['none']:
+        return frozenset()
+    unknown = [word for word in words if word not in SHADER_FEATURES]
+    if unknown:
+        log.warning("ignoring shader features %s: expected %s", ', '.join(unknown),
+                    ', '.join(SHADER_FEATURES))
+    return frozenset(word for word in words if word in SHADER_FEATURES)
+
+
 #: The bit of the block's flags word saying the vertex colours are baked light
 #: rather than a tint; the fragment shader reads it as ``bakedLightMode``.
 BAKED_LIGHT_BIT = 64
@@ -619,6 +642,9 @@ class PBRShaderProgram(VRML97ShaderProgram):
     #: and the extension maps :attr:`ext_channels` says the driver has units for.
     texture_units: tuple[tuple[str, int], ...] = tuple(PBR_UNITS.items())
     _ext_channels: Mapping[str, int] = MappingProxyType({})
+    #: The optional parts compiled in (:data:`SHADER_FEATURES`): None for every one the
+    #: driver can run. Read when the program compiles.
+    features: Optional[frozenset[str]] = None
 
     @property
     def ext_channels(self) -> Mapping[str, int]:
@@ -666,38 +692,46 @@ class PBRShaderProgram(VRML97ShaderProgram):
             # Bake the driver's shadow-light budget / cube path into pbr.frag,
             # mirroring the VRML97 program.
             self.MAX_SHADOW_LIGHTS, self.shadow_cube_array = resolve_shadow_config()
+            # What the application declared (``shaderFeatures``); None is every
+            # feature the driver has units for.
+            wanted = self.features
+
+            def wants(name: str) -> bool:
+                return wanted is None or name in wanted
             # Sampler-budget gate: extension textures (units 16+) only exist on a GPU
             # reporting more than the 16-unit GL 3.3 minimum (llvmpipe reports 16).
             self.texture_budget = int(glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS))
-            self.ext_channels = ext_texture_channels(self.texture_budget)
+            ext_textures = (wants('extension-textures')
+                            and ext_textures_supported(self.texture_budget))
+            self.ext_channels = (ext_texture_channels(self.texture_budget)
+                                 if wants('extension-textures') else {})
             # Reflections of the scene are read from a unit past the joint
             # palette; where the fragment stage stops short of it every
             # mirror reflects the environment probe alone.
             self.planar_reflection_supported = (
-                self.texture_budget >= REFLECTION_UNITS_NEEDED)
+                wants('planar-reflection') and self.texture_budget >= REFLECTION_UNITS_NEEDED)
             # A zone's own environment probe is a layer of the cube-map array
             # the scene's probe then lives in, which needs the same GL 4.0 /
             # ARB_texture_cube_map_array support the point-shadow cube arrays
             # do -- and the #extension line that support already enables.
-            self.zone_probes_supported = bool(self.shadow_cube_array)
+            self.zone_probes_supported = wants('zone-probes') and bool(self.shadow_cube_array)
             # The texture layers' cube map and 3D texture, and the texture
             # projectors' images, where the fragment stage has samplers left.
-            self.layer_samplers_supported = pbr_fragment_samplers(
-                ext_textures_supported(self.texture_budget),
-                self.planar_reflection_supported, bool(self.shadow_cube_array),
-                self.MAX_SHADOW_LIGHTS) + LAYER_SAMPLERS_NEEDED <= self.texture_budget
+            declared = pbr_fragment_samplers(
+                ext_textures, self.planar_reflection_supported, bool(self.shadow_cube_array),
+                self.MAX_SHADOW_LIGHTS)
+            self.layer_samplers_supported = (
+                wants('texture-layers') and declared + LAYER_SAMPLERS_NEEDED <= self.texture_budget)
             # The volume-scatter buffer's sampler, where one is left after those.
-            self.volume_scatter_supported = pbr_fragment_samplers(
-                ext_textures_supported(self.texture_budget),
-                self.planar_reflection_supported, bool(self.shadow_cube_array),
-                self.MAX_SHADOW_LIGHTS) + (LAYER_SAMPLERS_NEEDED if self.layer_samplers_supported
-                                           else 0) + 1 <= self.texture_budget
+            self.volume_scatter_supported = (
+                wants('volume-scatter')
+                and declared + (LAYER_SAMPLERS_NEEDED if self.layer_samplers_supported else 0) + 1
+                <= self.texture_budget)
             ext_defines = ['#define TEXTURE_LAYER_SAMPLERS %d'
                            % (1 if self.layer_samplers_supported else 0),
                            '#define TEXTURE_PROJECTORS %d'
                            % (1 if self.layer_samplers_supported else 0),
-                           '#define PBR_EXT_TEXTURES %d'
-                           % (1 if ext_textures_supported(self.texture_budget) else 0),
+                           '#define PBR_EXT_TEXTURES %d' % (1 if ext_textures else 0),
                            '#define PBR_PLANAR_REFLECTION %d'
                            % (1 if self.planar_reflection_supported else 0),
                            '#define PBR_VOLUME_SCATTER %d'
@@ -705,6 +739,9 @@ class PBRShaderProgram(VRML97ShaderProgram):
                            '#define PBR_ZONE_PROBES %d'
                            % (1 if self.zone_probes_supported else 0),
                            '#define MAX_ZONE_LAYERS %d' % (MAX_ZONE_LAYERS,)]
+            if wanted is not None:
+                ext_defines += pbr_feature_defines(
+                    [lobe for lobe in PBR_OPTIONAL_FEATURES if lobe.lower() in wanted])
             # Vertex-shader skinning needs a texture unit of its own for the
             # joint palette; a driver whose combined budget does not reach it
             # compiles the skinning out and the deform stays on the CPU.
@@ -1542,7 +1579,11 @@ class PBRPass(flatcore.FlatPass):
 
     def getShaderProgram(self) -> VRML97ShaderProgram:
         if self._shader_program_instance is None:
-            self._shader_program_instance = PBRShaderProgram()
+            program = PBRShaderProgram()
+            program.features = shader_features(renderoptions.choice(
+                self, 'shaderFeatures',
+                renderoptions.env_text_once('OPENGLCONTEXT_SHADER_FEATURES', 'all')))
+            self._shader_program_instance = program
         return self._shader_program_instance
 
     # Must match MAX_INSTANCE_MATERIALS in pbr.frag (sized to the 16 KB UBO min:
@@ -1628,7 +1669,18 @@ class PBRPass(flatcore.FlatPass):
                 memo[shape] = (made_from, stamps, key, flag)
             return key, flag
 
-        return (lambda shape: answer(shape)[0]), (lambda shape: answer(shape)[1])
+        # The pair serves one grouping, which asks a shape its key and then whether it can be
+        # drawn instanced: the first asking answers the second.
+        last: list[Any] = [None, None]
+
+        def answered(shape: Any) -> tuple[Any, bool]:
+            if last[0] is None or last[0]() is not shape:
+                last[1] = answer(shape)
+                last[0] = weakref.ref(shape)
+            found: tuple[Any, bool] = last[1]
+            return found
+
+        return (lambda shape: answered(shape)[0]), (lambda shape: answered(shape)[1])
 
     def _keyFor(self, shape: Any, collapse: bool) -> Any:
         from OpenGLContext.passes.instancing import (

{openglcontext-3.0.0a7 → openglcontext-3.0.0a8}/OpenGLContext/passes/shadowmath.py

@@ -260,6 +260,34 @@ def directional_cascade(light_dir: Vec3, corners_world: np.ndarray,
     return view.astype('f'), proj.astype('f')
 
 
+def padded_corners(corners_world: np.ndarray, scale: float) -> np.ndarray:
+    """``corners_world`` grown about their centre to ``scale`` times their size.
+
+    A cascade fitted to them reaches that much further than the slice it serves, so it keeps
+    serving the slice for as long as the slice moves less than the room made.
+    """
+    corners = np.asarray(corners_world, dtype='d')
+    if scale == 1.0:
+        return corners
+    centre = corners.mean(axis=0)
+    return centre + (corners - centre) * float(scale)
+
+
+def cascade_covers(view: Matrix4, proj: Matrix4, corners_world: np.ndarray,
+                   tolerance: float = 0.01) -> bool:
+    """Whether a cascade's light view and orthographic projection contain ``corners_world``.
+
+    A cascade is a box; a receiver in the slice is shadowed from it only where the box holds it,
+    sideways and in depth. ``tolerance`` is a share of the box's half width, which the fit's
+    snapping to texels takes from the edges.
+    """
+    corners = np.asarray(corners_world, dtype='d')
+    homogeneous = np.concatenate([corners, np.ones((corners.shape[0], 1))], axis=1)
+    clip = homogeneous @ np.asarray(view, dtype='d') @ np.asarray(proj, dtype='d')
+    ndc = clip[:, :3] / clip[:, 3:4]
+    return bool(np.all(np.abs(ndc) <= 1.0 + tolerance))
+
+
 def _extend_near_for_casters(caster_bounds: np.ndarray, view: Matrix4,
                              mins: np.ndarray, maxs: np.ndarray,
                              near: float) -> float: