OpenGLContext 3.0.0a4__tar.gz → 3.0.0a6__tar.gz

openglcontext-3.0.0a6/MANIFEST.in

@@ -0,0 +1,52 @@
+include MANIFEST.in
+include license.txt
+include README.md
+
+recursive-include tests *.jpg *.bmp *.png *.wrl *.jpeg
+exclude tests/axis.wrl
+exclude tests/flower.wrl
+exclude tests/test.jpg
+exclude tests/wrls/logo_installer.bmp
+exclude tests/wrls/pyopenglchapel.wrl
+include tests/*.py
+include tests/*.vert
+include tests/resources/*.txt
+
+# The documentation's source: the pages, the Sphinx configuration and its
+# extensions, templates and static files, the extension specifications, and
+# the pictures. The generated pages (docs/tutorials/*.rst, docs/api/) and the
+# built site are not source.
+include build-docs.py docs/*.rst docs/conf.py
+recursive-include docbuild *.py
+recursive-include docs/_ext *.py
+recursive-include docs/_templates *.html
+recursive-include docs/_static *.css *.js
+recursive-include docs/extensions *.rst *.json *.gltf
+recursive-include docs/images *.png *.jpg *.gif *.svg *.toml *.md *.json
+include docs/tutorials/*.png docs/tutorials/physics_getting_started.rst
+include OpenGLContext/resources/*.txt
+include OpenGLContext/loaders/*
+prune docs/_build
+prune docs/api
+exclude tests/test-results/*.png
+exclude tests/test-results/*.html
+
+# AI-workflow / internal planning docs are not user-facing; keep them out of the
+# published sdist.
+exclude CLAUDE.md
+prune plans
+
+global-exclude *CVS*
+global-exclude *Cvs*
+global-exclude *.pyc
+global-exclude *.pyo
+global-exclude *.pdb
+global-exclude *.db
+global-exclude *.max
+global-exclude *.gz
+global-exclude *.bat
+global-exclude *.profile
+global-exclude *.directory
+global-exclude *.cvsignore
+global-exclude *.ttf
+

openglcontext-3.0.0a6/OpenGLContext/__init__.py

@@ -0,0 +1,461 @@
+'''A 3D engine on PyOpenGL: scenes, a renderer, and a window to put it in
+
+OpenGLContext renders 3D scenes with PyOpenGL, in a window belonging to
+whichever GUI toolkit the application already uses.  GLFW, GLUT, Pygame,
+Tkinter, wxPython and Qt/PySide are all supported; GLFW is the one to reach
+for with the core profile, and Tkinter the one that needs nothing installed.
+A context can own the whole window or sit as one canvas inside a larger
+application.
+
+    from OpenGLContext.viewer import ViewerContext, ViewerOptions
+
+    class MyViewer(ViewerContext):
+        options = ViewerOptions(source='model.glb')
+
+    MyViewer.ContextMainLoop()
+
+What it holds:
+
+    scenegraph   VRML97-style nodes, plus the metallic/roughness material
+                 and mesh the glTF loader produces
+    loaders      glTF 2.0/GLB, VRML97, Wavefront OBJ and streamed 3D Tiles
+    passes       The core-profile and compatibility render passes, physically
+                 based rendering, image-based lighting, shadows, instancing
+    move         Walking, flying, swimming and mouse-look, with collision
+    physics      Rigid bodies, colliders, gravity zones and triggers
+    audio        Sound placed in the scene and heard from where you stand
+    ui           Panels, widgets and a settings screen over the live frame
+    viewer       The embeddable viewer that `oglc-view` is a command line for
+
+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.0a6"
+__author__ = "Michael Colin Fletcher"
+__license__ = "BSD-Style, see license.txt for details and exceptions"
+
+from OpenGLContext.plugins import Context,InteractiveContext,VRMLContext,Loader,Node,Adapter,WindowSystem,MovementMode,ViewGestures
+
+# The window systems a context opens on, by the name ContextDefinition's
+# `windowsystem` field gives.  Each module imports its toolkit, so none is
+# imported until a context asks for it.  GLFW first: it is what an empty
+# request opens.  See OpenGLContext.windowsystem.
+WindowSystem( 'glfw', 'OpenGLContext.windowsystem.glfw.GLFWWindowSystem' )
+WindowSystem( 'glut', 'OpenGLContext.windowsystem.glut.GLUTWindowSystem' )
+WindowSystem( 'pygame', 'OpenGLContext.windowsystem.pygame.PygameWindowSystem' )
+WindowSystem( 'tk', 'OpenGLContext.windowsystem.tk.TkWindowSystem' )
+WindowSystem( 'wx', 'OpenGLContext.windowsystem.wx.WxWindowSystem' )
+# Offscreen: no window, no display server.  One per platform -- EGL on Linux,
+# WGL pbuffers on Windows -- and both are registered everywhere, since which
+# one a machine can actually create is a question its answer already gives.
+WindowSystem( 'egl', 'OpenGLContext.windowsystem.egl.EGLWindowSystem' )
+WindowSystem( 'wgl', 'OpenGLContext.windowsystem.wgl.WGLWindowSystem' )
+
+# The movement modes a navigation declaration names, and the gestures a view
+# is moved by, each a factory making a new node.  See
+# OpenGLContext.move.navigationdefinition.
+MovementMode( 'examine', 'OpenGLContext.move.modes.examineMode' )
+MovementMode( 'walk', 'OpenGLContext.move.modes.walkMode' )
+MovementMode( 'fly', 'OpenGLContext.move.modes.flyMode' )
+MovementMode( 'swim', 'OpenGLContext.move.modes.swimMode' )
+MovementMode( 'fps', 'OpenGLContext.move.modes.fpsMode' )
+ViewGestures( 'plan', 'OpenGLContext.multiview.navigation.plan_mode' )
+ViewGestures( 'examine', 'OpenGLContext.multiview.navigation.examine_mode' )
+
+# The context class each window system's module publishes, which
+# getContextType and getInteractive(name) read.  Deprecated with
+# getContextType; a window system is chosen by the definition's field.
+Context( 'pygame', 'OpenGLContext.pygamecontext.PygameContext' )
+Context( 'wx', 'OpenGLContext.wxcontext.wxContext' )
+Context( 'glut', 'OpenGLContext.glutcontext.GLUTContext' )
+Context( 'glfw', 'OpenGLContext.glfwcontext.GLFWContext' )
+Context( 'tk', 'OpenGLContext.tkcontext.TkContext' )
+Context( 'egl', 'OpenGLContext.eglcontext.EGLContext' )
+Context( 'wgl', 'OpenGLContext.wglcontext.WGLContext' )
+InteractiveContext( 'pygame', 'OpenGLContext.pygameinteractivecontext.PygameInteractiveContext' )
+InteractiveContext( 'wx', 'OpenGLContext.wxinteractivecontext.wxInteractiveContext' )
+InteractiveContext( 'glut', 'OpenGLContext.glutinteractivecontext.GLUTInteractiveContext' )
+InteractiveContext( 'glfw', 'OpenGLContext.glfwinteractivecontext.GLFWInteractiveContext' )
+InteractiveContext( 'tk', 'OpenGLContext.tkinteractivecontext.TkInteractiveContext' )
+InteractiveContext( 'egl', 'OpenGLContext.eglcontext.EGLContext' )
+InteractiveContext( 'wgl', 'OpenGLContext.wglcontext.WGLContext' )
+VRMLContext( 'pygame', 'OpenGLContext.pygamevrmlcontext.VRMLContext' )
+VRMLContext( 'wx', 'OpenGLContext.wxvrmlcontext.VRMLContext' )
+VRMLContext( 'glut', 'OpenGLContext.glutvrmlcontext.VRMLContext' )
+VRMLContext( 'glfw', 'OpenGLContext.glfwvrmlcontext.VRMLContext' )
+VRMLContext( 'tk', 'OpenGLContext.tkvrmlcontext.VRMLContext' )
+VRMLContext( 'egl', 'OpenGLContext.eglvrmlcontext.VRMLContext' )
+VRMLContext( 'wgl', 'OpenGLContext.wglvrmlcontext.VRMLContext' )
+
+Loader( 'vrml97', 'OpenGLContext.loaders.vrml97.defaultHandler', ['.wrl','.wrz','.vrml','model/vrml','x-world/x-vrml','.wrl.gz'] )
+Loader( 'obj', 'OpenGLContext.loaders.obj.defaultHandler', ['.obj','.obj.gz'] )
+Loader( 'x3d', 'OpenGLContext.loaders.x3d.defaultHandler', ['.x3d','.x3dz','.x3dv','.x3dvz','.x3dj','.x3djz','.x3db','.x3d.gz','.x3dv.gz','.x3dj.gz','.x3db.gz'] )
+Loader( 'stl', 'OpenGLContext.loaders.meshfiles.stlHandler', ['.stl','.stl.gz'] )
+Loader( 'ply', 'OpenGLContext.loaders.meshfiles.plyHandler', ['.ply','.ply.gz'] )
+Loader( 'off', 'OpenGLContext.loaders.meshfiles.offHandler', ['.off','.off.gz'] )
+
+# What `oglc-view` can open, keyed by file suffix and content type. One viewer
+# serves every format; the adapter is chosen from the source itself.
+# A VRM avatar is a GLB; the loader keeps its VRMC extensions in scene.extensions.
+Adapter( 'gltf', 'OpenGLContext.viewer.adapters.gltf.GLTFAdapter', ['.gltf','.glb','.gltf.gz','.glb.gz','.vrm','model/gltf+json','model/gltf-binary','model/vrm'] )
+Adapter( 'vrml97', 'OpenGLContext.viewer.adapters.vrml.VRMLAdapter', ['.wrl','.wrz','.vrml','.wrl.gz','model/vrml','x-world/x-vrml'] )
+Adapter( 'obj', 'OpenGLContext.viewer.adapters.obj.OBJAdapter', ['.obj','.obj.gz','model/obj'] )
+# X3D JSON is usually named .json, so a document of that name is recognised by
+# its content (loaders.formats); served, its type is model/x3d+json. model/x3d+vrml is how ClassicVRML names its
+# type; model/x3d-vrml is the registered name. The compressed binary encoding
+# is model/x3d+fastinfoset by registration and model/x3d+binary by ISO/IEC
+# 19776-3.
+Adapter( 'x3d', 'OpenGLContext.viewer.adapters.x3d.X3DAdapter', ['.x3d','.x3dz','.x3dv','.x3dvz','.x3dj','.x3djz','.x3db','.x3d.gz','.x3dv.gz','.x3dj.gz','.x3db.gz','model/x3d+xml','model/x3d+vrml','model/x3d-vrml','model/x3d+json','model/x3d+fastinfoset','model/x3d+binary'] )
+# STL, PLY and OFF hold one mesh each (loaders.meshfiles); a PLY of 3D
+# Gaussian splats reads as a GaussianSplats node.
+Adapter( 'stl', 'OpenGLContext.viewer.adapters.meshfiles.STLAdapter', ['.stl','.stl.gz','model/stl'] )
+Adapter( 'ply', 'OpenGLContext.viewer.adapters.meshfiles.PLYAdapter', ['.ply','.ply.gz','model/ply'] )
+Adapter( 'off', 'OpenGLContext.viewer.adapters.meshfiles.OFFAdapter', ['.off','.off.gz','model/off'] )
+# A tileset is any .json, so the registry only claims the conventional name; a
+# document under another name is recognised by its content (loaders.formats).
+Adapter( 'tiles3d', 'OpenGLContext.viewer.adapters.tiles.TilesAdapter', ['tileset.json'] )
+
+Node( 'Anchor', 'OpenGLContext.scenegraph.anchor.Anchor' )
+Node( 'Appearance', 'OpenGLContext.scenegraph.appearance.Appearance' )
+Node( 'AudioEmitter', 'OpenGLContext.scenegraph.audio.AudioEmitter' )
+Node( 'AudioSource', 'OpenGLContext.scenegraph.audio.AudioSource' )
+Node( 'Background', 'OpenGLContext.scenegraph.background.Background' )
+Node( 'Billboard', 'OpenGLContext.scenegraph.billboard.Billboard' )
+Node( 'Box', 'OpenGLContext.scenegraph.box.Box' )
+Node( 'CADAssembly', 'OpenGLContext.scenegraph.x3dgroups.CADAssembly' )
+Node( 'CADFace', 'OpenGLContext.scenegraph.x3dgroups.CADFace' )
+Node( 'CADLayer', 'OpenGLContext.scenegraph.x3dgroups.CADLayer' )
+Node( 'CADPart', 'OpenGLContext.scenegraph.transform.CADPart' )
+Node( 'EspduTransform', 'OpenGLContext.scenegraph.transform.EspduTransform' )
+Node( 'Collision', 'OpenGLContext.scenegraph.collision.Collision' )
+Node( 'ClipPlane', 'vrml.x3d.nodes.ClipPlane' )
+Node( 'Color', 'vrml.vrml97.basenodes.Color' )
+Node( 'ColorInterpolator', 'OpenGLContext.scenegraph.interpolators.ColorInterpolator' )
+Node( 'Cone', 'OpenGLContext.scenegraph.quadrics.Cone' )
+Node( 'Coordinate', 'OpenGLContext.scenegraph.coordinate.Coordinate' )
+Node( 'CoordinateInterpolator', 'OpenGLContext.scenegraph.interpolators.CoordinateInterpolator' )
+Node( 'Cylinder', 'OpenGLContext.scenegraph.quadrics.Cylinder' )
+Node( 'CylinderSensor', 'OpenGLContext.scenegraph.x3dpointing.CylinderSensor' )
+Node( 'DirectionalLight', 'OpenGLContext.scenegraph.light.DirectionalLight' )
+Node( 'ElevationGrid', 'OpenGLContext.scenegraph.meshgeometry.ElevationGrid' )
+Node( 'Extrusion', 'OpenGLContext.scenegraph.extrusions.Extrusion' )
+Node( 'EnvironmentLight', 'OpenGLContext.scenegraph.environmentlight.EnvironmentLight' )
+Node( 'Fog', 'OpenGLContext.scenegraph.fog.Fog' )
+Node( 'FontLibrary', 'OpenGLContext.scenegraph.text.fontlibrary.FontLibrary' )
+Node( 'FontStyle', 'OpenGLContext.scenegraph.text.fontstyle3d.FontStyle' )
+Node( 'GaussianSplats', 'OpenGLContext.scenegraph.gaussiansplats.GaussianSplats' )
+Node( 'Gear', 'OpenGLContext.scenegraph.gear.Gear' )
+Node( 'Group', 'OpenGLContext.scenegraph.group.Group' )
+Node( 'GeoCoordinate', 'OpenGLContext.scenegraph.geospatial.GeoCoordinate' )
+Node( 'GeoElevationGrid', 'OpenGLContext.scenegraph.geospatial.GeoElevationGrid' )
+Node( 'GeoViewpoint', 'OpenGLContext.scenegraph.geospatial.GeoViewpoint' )
+Node( 'GeoProximitySensor', 'vrml.x3d.sensors.GeoProximitySensor' )
+Node( 'GeoTouchSensor', 'OpenGLContext.scenegraph.x3dpointing.GeoTouchSensor' )
+Node( 'GeoLOD', 'OpenGLContext.scenegraph.geospatial.GeoLOD' )
+Node( 'GeoPositionInterpolator', 'vrml.x3d.runtime.GeoPositionInterpolator' )
+Node( 'GeoLocation', 'OpenGLContext.scenegraph.geospatial.GeoLocation' )
+Node( 'GeoTransform', 'OpenGLContext.scenegraph.geospatial.GeoTransform' )
+Node( 'GeoOrigin', 'vrml.x3d.nodes.GeoOrigin' )
+Node( 'GeoMetadata', 'vrml.x3d.nodes.GeoMetadata' )
+Node( 'HAnimDisplacer', 'OpenGLContext.scenegraph.hanim.HAnimDisplacer' )
+Node( 'HAnimHumanoid', 'OpenGLContext.scenegraph.hanim.HAnimHumanoid' )
+Node( 'HAnimJoint', 'OpenGLContext.scenegraph.hanim.HAnimJoint' )
+Node( 'HAnimMotion', 'OpenGLContext.scenegraph.hanim.HAnimMotion' )
+Node( 'HAnimPose', 'OpenGLContext.scenegraph.hanim.HAnimPose' )
+Node( 'HAnimSegment', 'OpenGLContext.scenegraph.hanim.HAnimSegment' )
+Node( 'HAnimSite', 'OpenGLContext.scenegraph.hanim.HAnimSite' )
+Node( 'ImageTexture', 'OpenGLContext.scenegraph.imagetexture.ImageTexture' )
+Node( 'IndexedFaceSet', 'OpenGLContext.scenegraph.indexedfaceset.IndexedFaceSet' )
+Node( 'IndexedLineSet', 'OpenGLContext.scenegraph.indexedlineset.IndexedLineSet' )
+Node( 'Inline', 'OpenGLContext.scenegraph.inline.Inline' )
+Node( 'InlineGeometry', 'OpenGLContext.scenegraph.inlinegeometry.InlineGeometry' )
+Node( 'LocalFog', 'OpenGLContext.scenegraph.fog.LocalFog' )
+Node( 'LoadSensor', 'OpenGLContext.scenegraph.x3druntime.LoadSensor' )
+Node( 'LOD', 'OpenGLContext.scenegraph.lod.LOD' )
+Node( 'Material', 'OpenGLContext.scenegraph.material.Material' )
+Node( 'MouseOver', 'OpenGLContext.scenegraph.mouseover.MouseOver' )
+Node( 'MovieTexture', 'OpenGLContext.scenegraph.movietexture.MovieTexture' )
+Node( 'NavigationInfo', 'vrml.vrml97.basenodes.NavigationInfo' )
+Node( 'Normal', 'vrml.vrml97.basenodes.Normal' )
+Node( 'NormalInterpolator', 'OpenGLContext.scenegraph.interpolators.NormalInterpolator' )
+Node( 'OrientationInterpolator', 'OpenGLContext.scenegraph.interpolators.OrientationInterpolator' )
+Node( 'PickableGroup', 'OpenGLContext.scenegraph.x3dgroups.PickableGroup' )
+Node( 'LinePickSensor', 'vrml.x3d.picking.LinePickSensor' )
+Node( 'PointPickSensor', 'vrml.x3d.picking.PointPickSensor' )
+Node( 'PrimitivePickSensor', 'vrml.x3d.picking.PrimitivePickSensor' )
+Node( 'VolumePickSensor', 'vrml.x3d.picking.VolumePickSensor' )
+Node( 'StaticGroup', 'OpenGLContext.scenegraph.x3dgroups.StaticGroup' )
+Node( 'PixelTexture', 'OpenGLContext.scenegraph.imagetexture.PixelTexture' )
+Node( 'PlanarReflector', 'OpenGLContext.scenegraph.reflector.PlanarReflector' )
+Node( 'PlaneSensor', 'OpenGLContext.scenegraph.x3dpointing.PlaneSensor' )
+Node( 'PolyCone', 'OpenGLContext.scenegraph.extrusions.PolyCone' )
+Node( 'PolyCylinder', 'OpenGLContext.scenegraph.extrusions.PolyCylinder' )
+Node( 'PointLight', 'OpenGLContext.scenegraph.light.PointLight' )
+Node( 'ParticleEmitter', 'OpenGLContext.scenegraph.particles.ParticleEmitter' )
+Node( 'PointSet', 'OpenGLContext.scenegraph.pointset.PointSet' )
+Node( 'PositionInterpolator', 'OpenGLContext.scenegraph.interpolators.PositionInterpolator' )
+Node( 'ProximitySensor', 'vrml.x3d.sensors.ProximitySensor' )
+Node( 'ScalarInterpolator', 'OpenGLContext.scenegraph.interpolators.ScalarInterpolator' )
+Node( 'ScreenCoverageLOD', 'OpenGLContext.scenegraph.lod.ScreenCoverageLOD' )
+Node( 'Shape', 'OpenGLContext.scenegraph.shape.Shape' )
+Node( 'Sphere', 'OpenGLContext.scenegraph.quadrics.Sphere' )
+Node( 'SphereSensor', 'OpenGLContext.scenegraph.x3dpointing.SphereSensor' )
+Node( 'SpotLight', 'OpenGLContext.scenegraph.light.SpotLight' )
+Node( 'Switch', 'OpenGLContext.scenegraph.switch.Switch' )
+Node( 'Teapot', 'OpenGLContext.scenegraph.teapot.Teapot' )
+Node( 'Text', 'OpenGLContext.scenegraph.text.text.Text' )
+Node( 'TextureCoordinate', 'vrml.vrml97.basenodes.TextureCoordinate' )
+Node( 'TextureTransform', 'OpenGLContext.scenegraph.texturetransform.TextureTransform' )
+Node( 'TimeSensor', 'OpenGLContext.scenegraph.timesensor.TimeSensor' )
+Node( 'TouchSensor', 'OpenGLContext.scenegraph.x3dpointing.TouchSensor' )
+Node( 'TextureBackground', 'OpenGLContext.scenegraph.texturebackground.TextureBackground' )
+Node( 'TwoSidedMaterial', 'vrml.x3d.nodes.TwoSidedMaterial' )
+Node( 'Transform', 'OpenGLContext.scenegraph.transform.Transform' )
+Node( 'TransformSensor', 'vrml.x3d.sensors.TransformSensor' )
+Node( 'Viewpoint', 'OpenGLContext.scenegraph.viewpoint.Viewpoint' )
+Node( 'ViewpointGroup', 'OpenGLContext.scenegraph.viewpointgroup.ViewpointGroup' )
+Node( 'OrthoViewpoint', 'OpenGLContext.scenegraph.viewpoint.OrthoViewpoint' )
+Node( 'VisibilitySensor', 'vrml.x3d.sensors.VisibilitySensor' )
+Node( 'WorldInfo', 'vrml.vrml97.basenodes.WorldInfo' )
+Node( 'Zone', 'OpenGLContext.scenegraph.zone.Zone' )
+Node( 'ZoneAudio', 'OpenGLContext.scenegraph.zone.ZoneAudio' )
+Node( 'ZoneEnvironment', 'OpenGLContext.scenegraph.zone.ZoneEnvironment' )
+Node( 'ZoneGravity', 'OpenGLContext.scenegraph.zone.ZoneGravity' )
+Node( 'ZoneLights', 'OpenGLContext.scenegraph.zone.ZoneLights' )
+Node( 'ZoneMirrors', 'OpenGLContext.scenegraph.zone.ZoneMirrors' )
+Node( 'ZoneReverb', 'OpenGLContext.scenegraph.zone.ZoneReverb' )
+Node( 'ZoneVisibility', 'OpenGLContext.scenegraph.zone.ZoneVisibility' )
+Node( 'sceneGraph', 'OpenGLContext.scenegraph.scenegraph.SceneGraph' )
+Node( 'X3DScene', 'OpenGLContext.scenegraph.scenegraph.X3DScene' )
+Node( 'TriangleSet', 'OpenGLContext.scenegraph.meshgeometry.TriangleSet' )
+Node( 'IndexedTriangleSet', 'OpenGLContext.scenegraph.meshgeometry.IndexedTriangleSet' )
+Node( 'QuadSet', 'OpenGLContext.scenegraph.meshgeometry.QuadSet' )
+Node( 'IndexedQuadSet', 'OpenGLContext.scenegraph.meshgeometry.IndexedQuadSet' )
+Node( 'TriangleFanSet', 'OpenGLContext.scenegraph.meshgeometry.TriangleFanSet' )
+Node( 'IndexedTriangleFanSet', 'OpenGLContext.scenegraph.meshgeometry.IndexedTriangleFanSet' )
+Node( 'TriangleStripSet', 'OpenGLContext.scenegraph.meshgeometry.TriangleStripSet' )
+Node( 'IndexedTriangleStripSet', 'OpenGLContext.scenegraph.meshgeometry.IndexedTriangleStripSet' )
+Node( 'LineSet', 'OpenGLContext.scenegraph.meshgeometry.LineSet' )
+# X3D's Sound component, on omi_audio's processing graph (scenegraph.x3dsound).
+Node( 'Analyser', 'OpenGLContext.scenegraph.x3dsound.Analyser' )
+Node( 'AudioClip', 'OpenGLContext.scenegraph.x3dsound.AudioClip' )
+Node( 'AudioDestination', 'OpenGLContext.scenegraph.x3dsound.AudioDestination' )
+Node( 'BiquadFilter', 'OpenGLContext.scenegraph.x3dsound.BiquadFilter' )
+Node( 'BufferAudioSource', 'OpenGLContext.scenegraph.x3dsound.BufferAudioSource' )
+Node( 'ChannelMerger', 'OpenGLContext.scenegraph.x3dsound.ChannelMerger' )
+Node( 'ChannelSelector', 'OpenGLContext.scenegraph.x3dsound.ChannelSelector' )
+Node( 'ChannelSplitter', 'OpenGLContext.scenegraph.x3dsound.ChannelSplitter' )
+Node( 'Convolver', 'OpenGLContext.scenegraph.x3dsound.Convolver' )
+Node( 'Delay', 'OpenGLContext.scenegraph.x3dsound.Delay' )
+Node( 'DynamicsCompressor', 'OpenGLContext.scenegraph.x3dsound.DynamicsCompressor' )
+Node( 'Gain', 'OpenGLContext.scenegraph.x3dsound.Gain' )
+Node( 'ListenerPointSource', 'OpenGLContext.scenegraph.x3dsound.ListenerPointSource' )
+Node( 'MicrophoneSource', 'OpenGLContext.scenegraph.x3dsound.MicrophoneSource' )
+Node( 'OscillatorSource', 'OpenGLContext.scenegraph.x3dsound.OscillatorSource' )
+Node( 'PeriodicWave', 'OpenGLContext.scenegraph.x3dsound.PeriodicWave' )
+Node( 'Sound', 'OpenGLContext.scenegraph.x3dsound.Sound' )
+Node( 'SpatialSound', 'OpenGLContext.scenegraph.x3dsound.SpatialSound' )
+Node( 'StreamAudioDestination', 'OpenGLContext.scenegraph.x3dsound.StreamAudioDestination' )
+Node( 'StreamAudioSource', 'OpenGLContext.scenegraph.x3dsound.StreamAudioSource' )
+Node( 'WaveShaper', 'OpenGLContext.scenegraph.x3dsound.WaveShaper' )
+Node( 'ParticleSystem', 'OpenGLContext.scenegraph.x3dparticles.ParticleSystem' )
+Node( 'ConeEmitter', 'OpenGLContext.scenegraph.x3dparticles.ConeEmitter' )
+Node( 'ExplosionEmitter', 'OpenGLContext.scenegraph.x3dparticles.ExplosionEmitter' )
+Node( 'PointEmitter', 'OpenGLContext.scenegraph.x3dparticles.PointEmitter' )
+Node( 'PolylineEmitter', 'OpenGLContext.scenegraph.x3dparticles.PolylineEmitter' )
+Node( 'SurfaceEmitter', 'OpenGLContext.scenegraph.x3dparticles.SurfaceEmitter' )
+Node( 'VolumeEmitter', 'OpenGLContext.scenegraph.x3dparticles.VolumeEmitter' )
+Node( 'BoundedPhysicsModel', 'OpenGLContext.scenegraph.x3dparticles.BoundedPhysicsModel' )
+Node( 'ForcePhysicsModel', 'OpenGLContext.scenegraph.x3dparticles.ForcePhysicsModel' )
+Node( 'WindPhysicsModel', 'OpenGLContext.scenegraph.x3dparticles.WindPhysicsModel' )
+Node( 'Rectangle2D', 'OpenGLContext.scenegraph.geometry2d.Rectangle2D' )
+Node( 'TriangleSet2D', 'OpenGLContext.scenegraph.geometry2d.TriangleSet2D' )
+Node( 'Disk2D', 'OpenGLContext.scenegraph.geometry2d.Disk2D' )
+Node( 'ArcClose2D', 'OpenGLContext.scenegraph.geometry2d.ArcClose2D' )
+Node( 'Circle2D', 'OpenGLContext.scenegraph.geometry2d.Circle2D' )
+Node( 'Arc2D', 'OpenGLContext.scenegraph.geometry2d.Arc2D' )
+Node( 'Polypoint2D', 'OpenGLContext.scenegraph.geometry2d.Polypoint2D' )
+# X3D's event utilities: pyvrml97's behaviours, and the engine's clock and keys.
+Node( 'BooleanFilter', 'vrml.x3d.runtime.BooleanFilter' )
+Node( 'BooleanToggle', 'vrml.x3d.runtime.BooleanToggle' )
+Node( 'BooleanTrigger', 'vrml.x3d.runtime.BooleanTrigger' )
+Node( 'IntegerTrigger', 'vrml.x3d.runtime.IntegerTrigger' )
+Node( 'BooleanSequencer', 'vrml.x3d.runtime.BooleanSequencer' )
+Node( 'IntegerSequencer', 'vrml.x3d.runtime.IntegerSequencer' )
+Node( 'TimeTrigger', 'OpenGLContext.scenegraph.x3druntime.TimeTrigger' )
+Node( 'PositionInterpolator2D', 'vrml.x3d.runtime.PositionInterpolator2D' )
+Node( 'CoordinateInterpolator2D', 'vrml.x3d.runtime.CoordinateInterpolator2D' )
+Node( 'SplinePositionInterpolator', 'vrml.x3d.runtime.SplinePositionInterpolator' )
+Node( 'SplinePositionInterpolator2D', 'vrml.x3d.runtime.SplinePositionInterpolator2D' )
+Node( 'SplineScalarInterpolator', 'vrml.x3d.runtime.SplineScalarInterpolator' )
+Node( 'SquadOrientationInterpolator', 'vrml.x3d.runtime.SquadOrientationInterpolator' )
+Node( 'EaseInEaseOut', 'vrml.x3d.runtime.EaseInEaseOut' )
+Node( 'KeySensor', 'OpenGLContext.scenegraph.x3druntime.KeySensor' )
+# X3D's Layering and Layout components (scenegraph.layering): the layers a
+# scene is drawn as, and the groups the render pass places on the screen.
+Node( 'Layer', 'OpenGLContext.scenegraph.layering.Layer' )
+Node( 'LayerSet', 'OpenGLContext.scenegraph.layering.LayerSet' )
+Node( 'Layout', 'vrml.x3d.nodes.Layout' )
+Node( 'LayoutGroup', 'OpenGLContext.scenegraph.layering.LayoutGroup' )
+Node( 'LayoutLayer', 'OpenGLContext.scenegraph.layering.LayoutLayer' )
+Node( 'ScreenFontStyle', 'OpenGLContext.scenegraph.text.fontstyle3d.ScreenFontStyle' )
+Node( 'ScreenGroup', 'OpenGLContext.scenegraph.layering.ScreenGroup' )
+Node( 'Viewport', 'OpenGLContext.scenegraph.layering.Viewport' )
+Node( 'StringSensor', 'OpenGLContext.scenegraph.x3druntime.StringSensor' )
+# X3D's followers, ticked through the render queue on the engine's clock.
+Node( 'ColorChaser', 'OpenGLContext.scenegraph.x3druntime.ColorChaser' )
+Node( 'ColorDamper', 'OpenGLContext.scenegraph.x3druntime.ColorDamper' )
+Node( 'CoordinateChaser', 'OpenGLContext.scenegraph.x3druntime.CoordinateChaser' )
+Node( 'CoordinateDamper', 'OpenGLContext.scenegraph.x3druntime.CoordinateDamper' )
+Node( 'OrientationChaser', 'OpenGLContext.scenegraph.x3druntime.OrientationChaser' )
+Node( 'OrientationDamper', 'OpenGLContext.scenegraph.x3druntime.OrientationDamper' )
+Node( 'PositionChaser', 'OpenGLContext.scenegraph.x3druntime.PositionChaser' )
+Node( 'PositionDamper', 'OpenGLContext.scenegraph.x3druntime.PositionDamper' )
+Node( 'PositionChaser2D', 'OpenGLContext.scenegraph.x3druntime.PositionChaser2D' )
+Node( 'PositionDamper2D', 'OpenGLContext.scenegraph.x3druntime.PositionDamper2D' )
+Node( 'ScalarChaser', 'OpenGLContext.scenegraph.x3druntime.ScalarChaser' )
+Node( 'ScalarDamper', 'OpenGLContext.scenegraph.x3druntime.ScalarDamper' )
+Node( 'TexCoordChaser2D', 'OpenGLContext.scenegraph.x3druntime.TexCoordChaser2D' )
+Node( 'TexCoordDamper2D', 'OpenGLContext.scenegraph.x3druntime.TexCoordDamper2D' )
+# X3D nodes that are data the engine reads through their declarations.
+Node( 'ColorRGBA', 'vrml.x3d.nodes.ColorRGBA' )
+Node( 'AcousticProperties', 'vrml.x3d.nodes.AcousticProperties' )
+Node( 'TextureCoordinateGenerator', 'vrml.x3d.nodes.TextureCoordinateGenerator' )
+Node( 'MultiTextureCoordinate', 'vrml.x3d.nodes.MultiTextureCoordinate' )
+Node( 'MultiTextureTransform', 'vrml.x3d.nodes.MultiTextureTransform' )
+Node( 'TextureTransformMatrix3D', 'vrml.x3d.nodes.TextureTransformMatrix3D' )
+Node( 'TextureProperties', 'vrml.x3d.nodes.TextureProperties' )
+Node( 'Tangent', 'vrml.x3d.nodes.Tangent' )
+Node( 'CoordinateDouble', 'vrml.x3d.nodes.CoordinateDouble' )
+Node( 'LineProperties', 'vrml.x3d.nodes.LineProperties' )
+Node( 'PointProperties', 'vrml.x3d.nodes.PointProperties' )
+Node( 'FillProperties', 'vrml.x3d.nodes.FillProperties' )
+Node( 'MetadataBoolean', 'vrml.x3d.nodes.MetadataBoolean' )
+Node( 'MetadataDouble', 'vrml.x3d.nodes.MetadataDouble' )
+Node( 'MetadataFloat', 'vrml.x3d.nodes.MetadataFloat' )
+Node( 'MetadataInteger', 'vrml.x3d.nodes.MetadataInteger' )
+Node( 'MetadataSet', 'vrml.x3d.nodes.MetadataSet' )
+Node( 'MetadataString', 'vrml.x3d.nodes.MetadataString' )
+# X3D's RigidBodyPhysics: the collection and sensor step on the engine's clock,
+# the collidables draw; bodies, collections, spaces, contacts and joints are data.
+Node( 'RigidBodyCollection', 'OpenGLContext.scenegraph.x3drigidbody.RigidBodyCollection' )
+Node( 'CollisionSensor', 'OpenGLContext.scenegraph.x3drigidbody.CollisionSensor' )
+Node( 'CollidableShape', 'OpenGLContext.scenegraph.x3drigidbody.CollidableShape' )
+Node( 'CollidableOffset', 'OpenGLContext.scenegraph.x3drigidbody.CollidableOffset' )
+Node( 'RigidBody', 'vrml.x3d.nodes.RigidBody' )
+Node( 'CollisionCollection', 'vrml.x3d.nodes.CollisionCollection' )
+Node( 'CollisionSpace', 'vrml.x3d.nodes.CollisionSpace' )
+Node( 'Contact', 'vrml.x3d.nodes.Contact' )
+Node( 'BallJoint', 'vrml.x3d.nodes.BallJoint' )
+Node( 'DoubleAxisHingeJoint', 'vrml.x3d.nodes.DoubleAxisHingeJoint' )
+Node( 'MotorJoint', 'vrml.x3d.nodes.MotorJoint' )
+Node( 'SingleAxisHingeJoint', 'vrml.x3d.nodes.SingleAxisHingeJoint' )
+Node( 'SliderJoint', 'vrml.x3d.nodes.SliderJoint' )
+Node( 'UniversalJoint', 'vrml.x3d.nodes.UniversalJoint' )
+# X3D's MultiTexture, CubeMapTexturing and Texturing3D.
+Node( 'RenderedTexture', 'OpenGLContext.scenegraph.renderedtexture.RenderedTexture' )
+Node( 'TextureProjector', 'OpenGLContext.scenegraph.textureprojector.TextureProjector' )
+Node( 'TextureProjectorParallel', 'OpenGLContext.scenegraph.textureprojector.TextureProjectorParallel' )
+Node( 'MultiTexture', 'OpenGLContext.scenegraph.multitexture.MultiTexture' )
+Node( 'ComposedCubeMapTexture', 'OpenGLContext.scenegraph.cubemaptexture.ComposedCubeMapTexture' )
+Node( 'ImageCubeMapTexture', 'OpenGLContext.scenegraph.cubemaptexture.ImageCubeMapTexture' )
+Node( 'GeneratedCubeMapTexture', 'OpenGLContext.scenegraph.cubemaptexture.GeneratedCubeMapTexture' )
+Node( 'ImageTexture3D', 'OpenGLContext.scenegraph.texture3d.ImageTexture3D' )
+Node( 'ComposedTexture3D', 'OpenGLContext.scenegraph.texture3d.ComposedTexture3D' )
+Node( 'PixelTexture3D', 'OpenGLContext.scenegraph.texture3d.PixelTexture3D' )
+Node( 'VolumeData', 'OpenGLContext.scenegraph.volumedata.VolumeData' )
+Node( 'SegmentedVolumeData', 'OpenGLContext.scenegraph.volumedata.SegmentedVolumeData' )
+Node( 'IsoSurfaceVolumeData', 'OpenGLContext.scenegraph.volumedata.IsoSurfaceVolumeData' )
+Node( 'BlendedVolumeStyle', 'OpenGLContext.scenegraph.volumestyles.BlendedVolumeStyle' )
+Node( 'BoundaryEnhancementVolumeStyle', 'OpenGLContext.scenegraph.volumestyles.BoundaryEnhancementVolumeStyle' )
+Node( 'CartoonVolumeStyle', 'OpenGLContext.scenegraph.volumestyles.CartoonVolumeStyle' )
+Node( 'ComposedVolumeStyle', 'OpenGLContext.scenegraph.volumestyles.ComposedVolumeStyle' )
+Node( 'EdgeEnhancementVolumeStyle', 'OpenGLContext.scenegraph.volumestyles.EdgeEnhancementVolumeStyle' )
+Node( 'OpacityMapVolumeStyle', 'OpenGLContext.scenegraph.volumestyles.OpacityMapVolumeStyle' )
+Node( 'ProjectionVolumeStyle', 'OpenGLContext.scenegraph.volumestyles.ProjectionVolumeStyle' )
+Node( 'ShadedVolumeStyle', 'OpenGLContext.scenegraph.volumestyles.ShadedVolumeStyle' )
+Node( 'SilhouetteEnhancementVolumeStyle', 'OpenGLContext.scenegraph.volumestyles.SilhouetteEnhancementVolumeStyle' )
+Node( 'ToneMappedVolumeStyle', 'OpenGLContext.scenegraph.volumestyles.ToneMappedVolumeStyle' )
+Node( 'TextureCoordinate3D', 'vrml.x3d.nodes.TextureCoordinate3D' )
+Node( 'TextureCoordinate4D', 'vrml.x3d.nodes.TextureCoordinate4D' )
+Node( 'TextureTransform3D', 'vrml.x3d.nodes.TextureTransform3D' )
+Node( 'ImageBasedLight', 'OpenGLContext.scenegraph.imagebasedlight.ImageBasedLight' )
+Node( 'IndexedPolygons', 'OpenGLContext.scenegraph.indexedpolygons.IndexedPolygons' )
+Node( 'FontStyle3D', 'OpenGLContext.scenegraph.text.fontstyle3d.FontStyle3D' )
+Node( 'SimpleBackground', 'OpenGLContext.scenegraph.simplebackground.SimpleBackground' )
+Node( 'CubeBackground', 'OpenGLContext.scenegraph.cubebackground.CubeBackground' )
+Node( 'SphereBackground', 'OpenGLContext.scenegraph.spherebackground.SphereBackground' )
+Node( 'MMImageTexture', 'OpenGLContext.scenegraph.imagetexture.MMImageTexture' )
+Node( 'Contour2D', 'OpenGLContext.scenegraph.nurbs.Contour2D' )
+Node( 'CoordinateDeformer', 'OpenGLContext.scenegraph.coordinatedeformer.CoordinateDeformer' )
+Node( 'NurbsCurve', 'OpenGLContext.scenegraph.nurbs.NurbsCurve' )
+Node( 'NurbsCurve2D', 'OpenGLContext.scenegraph.nurbs.NurbsCurve2D' )
+Node( 'NurbsDomainDistanceSample', 'OpenGLContext.scenegraph.nurbs.NurbsDomainDistanceSample' )
+Node( 'NurbsSurface', 'OpenGLContext.scenegraph.nurbs.NurbsSurface' )
+Node( 'NurbsToleranceSample', 'OpenGLContext.scenegraph.nurbs.NurbsToleranceSample' )
+Node( 'Polyline2D', 'OpenGLContext.scenegraph.nurbs.Polyline2D' )
+Node( 'TrimmedSurface', 'OpenGLContext.scenegraph.nurbs.TrimmedSurface' )
+Node( 'ContourPolyline2D', 'OpenGLContext.scenegraph.nurbsx3d.ContourPolyline2D' )
+Node( 'NurbsPatchSurface', 'OpenGLContext.scenegraph.nurbsx3d.NurbsPatchSurface' )
+Node( 'NurbsTrimmedSurface', 'OpenGLContext.scenegraph.nurbsx3d.NurbsTrimmedSurface' )
+Node( 'NurbsSweptSurface', 'OpenGLContext.scenegraph.nurbsx3d.NurbsSweptSurface' )
+Node( 'NurbsSwungSurface', 'OpenGLContext.scenegraph.nurbsx3d.NurbsSwungSurface' )
+Node( 'NurbsSet', 'OpenGLContext.scenegraph.nurbsx3d.NurbsSet' )
+Node( 'NurbsTextureCoordinate', 'OpenGLContext.scenegraph.nurbsx3d.NurbsTextureCoordinate' )
+Node( 'NurbsPositionInterpolator', 'OpenGLContext.scenegraph.nurbsinterpolators.NurbsPositionInterpolator' )
+Node( 'NurbsOrientationInterpolator', 'OpenGLContext.scenegraph.nurbsinterpolators.NurbsOrientationInterpolator' )
+Node( 'NurbsSurfaceInterpolator', 'OpenGLContext.scenegraph.nurbsinterpolators.NurbsSurfaceInterpolator' )
+
+for suffix in ('1f','2f','3f','4f','m2','m3','m4','m2x3','m3x2','m2x4','m4x2','m3x4','m4x3'):
+    Node( 'FloatUniform'+suffix,'OpenGLContext.scenegraph.shaders.FloatUniform'+suffix )
+for suffix in ('1i','2i','3i','4i'):
+    Node( 'IntUniform'+suffix,'OpenGLContext.scenegraph.shaders.IntUniform'+suffix )
+Node( 'TextureUniform','OpenGLContext.scenegraph.shaders.TextureUniform' )
+Node( 'TextureBufferUniform','OpenGLContext.scenegraph.shaders.TextureBufferUniform' )
+Node( 'GLSLShader','OpenGLContext.scenegraph.shaders.GLSLShader' )
+Node( 'GLSLObject','OpenGLContext.scenegraph.shaders.GLSLObject' )
+Node( 'GLSLImport','OpenGLContext.scenegraph.shaders.GLSLImport' )
+
+Node( 'ShaderAttribute','OpenGLContext.scenegraph.shaders.ShaderAttribute' )
+Node( 'ShaderBuffer','OpenGLContext.scenegraph.shaders.ShaderBuffer' )
+Node( 'ShaderIndexBuffer','OpenGLContext.scenegraph.shaders.ShaderIndexBuffer' )
+Node( 'ShaderSlice','OpenGLContext.scenegraph.shaders.ShaderSlice' )
+Node( 'ShaderGeometry','OpenGLContext.scenegraph.shaders.ShaderGeometry' )
+
+Node( 'Shader','OpenGLContext.scenegraph.shaders.Shader' )
+# X3D's programmable shaders (docs/x3d.rst)
+Node( 'ComposedShader','OpenGLContext.scenegraph.x3dshaders.ComposedShader' )
+Node( 'ProgramShader','OpenGLContext.scenegraph.x3dshaders.ProgramShader' )
+Node( 'PackagedShader','OpenGLContext.scenegraph.x3dshaders.PackagedShader' )
+Node( 'ShaderPart','OpenGLContext.scenegraph.x3dshaders.ShaderPart' )
+Node( 'ShaderProgram','OpenGLContext.scenegraph.x3dshaders.ShaderProgram' )
+Node( 'FloatVertexAttribute','vrml.x3d.nodes.FloatVertexAttribute' )
+Node( 'Matrix3VertexAttribute','vrml.x3d.nodes.Matrix3VertexAttribute' )
+Node( 'Matrix4VertexAttribute','vrml.x3d.nodes.Matrix4VertexAttribute' )
+Node( 'ROUTE','vrml.route.ROUTE' )
+Node( 'IS','vrml.route.IS' )
+
+Node( 'PhysicalMaterial', 'OpenGLContext.scenegraph.physicalmaterial.PhysicalMaterial' )
+Node( 'ImageDataTexture', 'OpenGLContext.scenegraph.imagedata.ImageDataTexture' )
+Node( 'UnlitMaterial', 'OpenGLContext.scenegraph.unlitmaterial.UnlitMaterial' )
+Node( 'AnisotropyMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.AnisotropyMaterialExtension' )
+Node( 'ClearcoatMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.ClearcoatMaterialExtension' )
+Node( 'DiffuseTransmissionMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.DiffuseTransmissionMaterialExtension' )
+Node( 'DispersionMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.DispersionMaterialExtension' )
+Node( 'EmissiveStrengthMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.EmissiveStrengthMaterialExtension' )
+Node( 'IORMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.IORMaterialExtension' )
+Node( 'IridescenceMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.IridescenceMaterialExtension' )
+Node( 'RetroreflectionMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.RetroreflectionMaterialExtension' )
+Node( 'SheenMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.SheenMaterialExtension' )
+Node( 'SpecularMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.SpecularMaterialExtension' )
+Node( 'TransmissionMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.TransmissionMaterialExtension' )
+Node( 'VolumeMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.VolumeMaterialExtension' )
+Node( 'VolumeScatterMaterialExtension', 'OpenGLContext.scenegraph.materialextensions.VolumeScatterMaterialExtension' )
+Node( 'SpecularGlossinessMaterial', 'OpenGLContext.scenegraph.specularglossiness.SpecularGlossinessMaterial' )
+Node( 'BlendMode', 'OpenGLContext.scenegraph.rendermodes.BlendMode' )
+Node( 'DepthMode', 'OpenGLContext.scenegraph.rendermodes.DepthMode' )
+Node( 'InstancedShape', 'OpenGLContext.scenegraph.instancedshape.InstancedShape' )
+Node( 'ImageTextureAtlas', 'OpenGLContext.scenegraph.texture3d.ImageTextureAtlas' )
+Node( 'FogCoordinate', 'OpenGLContext.scenegraph.fogcoordinate.FogCoordinate' )

openglcontext-3.0.0a6/OpenGLContext/__pyinstaller/__init__.py

@@ -0,0 +1,17 @@
+"""PyInstaller hooks for OpenGLContext
+
+PyInstaller finds these through the ``pyinstaller40`` entry point declared in
+``pyproject.toml``: it calls :func:`get_hook_dirs` and reads every
+``hook-*.py`` in the directory returned. An application freezing itself needs
+to do nothing to switch them on, and nothing here is imported when the engine
+is merely used.
+
+What an application does choose is in :mod:`OpenGLContext.packaging`.
+"""
+
+import os
+
+
+def get_hook_dirs() -> list[str]:
+    """Directories PyInstaller should read hooks from"""
+    return [os.path.dirname(__file__)]

openglcontext-3.0.0a6/OpenGLContext/__pyinstaller/hook-OpenGLContext.py

@@ -0,0 +1,53 @@
+"""What a frozen application needs from the engine beyond its import statements
+
+Three sets of things the engine reaches by name rather than by importing:
+
+* the plug-in registries (:mod:`OpenGLContext.plugins`) -- the windowing
+  backends, the format loaders, the viewer's adapters and every scenegraph node,
+  each declared as a string and imported when a scene asks for it,
+* the generated resource and font-atlas modules, loaded by name from a
+  ``res://`` URL and from the size a piece of text is drawn at, and
+* the files the engine opens by path: the GLSL sources the render passes are
+  built from, and the environment maps a default background is lit by.
+
+Each is reported from the source the running engine uses, so a node or a shader
+added to the engine reaches a frozen application without an edit here.
+
+The whole registry is reported, PyOpenGL's own entries included: an application
+built on the engine imports both, and naming a module twice costs nothing.
+Modules for a toolkit that is not installed are reported too and end up as
+missing-import notes in the build log rather than as failures -- the backend
+reports itself unavailable at run time, which is what a bundle wants. To leave
+an unwanted toolkit out altogether, pass
+:func:`OpenGLContext.packaging.unused_backend_modules` to ``excludes``.
+"""
+
+
+from PyInstaller import isolated
+from PyInstaller.utils.hooks import collect_data_files, collect_submodules
+
+
+@isolated.decorate
+def _plugin_modules() -> list[str]:
+    """Modules the plug-in registries would import, the engine's own included"""
+    import OpenGLContext  # imported for its registrations
+    from OpenGL import plugins
+
+    modules: list[str] = plugins.registered_modules()
+    return modules
+
+
+hiddenimports = (
+    _plugin_modules()
+    # `res://` URLs and the text renderer name these modules at run time; they
+    # are generated Python holding the bytes of an icon, a shader or a font
+    # atlas, so they travel as code rather than as data files.
+    + collect_submodules('OpenGLContext.resources')
+    + collect_submodules('OpenGLContext.scenegraph.text.fonts')
+)
+
+# The shaders, the environment maps and the atlas images beside their generated
+# modules: everything in the package that is not Python. It is under half a
+# megabyte all together, so it is collected wholesale rather than by a list of
+# patterns that would go stale as passes are added.
+datas = collect_data_files('OpenGLContext')