OpenGLContext

A car on a two-lane road through dense forest, seen from behind and above — **GLinting Steel** — a lap of a baked 3D Tiles world, streamed in around the car as it drives. GLinting Steel

A glass and metal chess set on a board, outdoors under a bright sky — Glass, metal and marble under image-based lighting, with screen-space transmission through the glass pieces. A Beautiful Game, © ASWF and Ed Mackey, CC-BY 4.0

A hillside of firs over undergrowth, seen from standing height — **`oglc-forest`** — half a million instanced trees and grass clumps on a real digital elevation model, walked at eye height. the forest demo

A city of blocky buildings stretching to the horizon under a clear sky — An OGC 3D Tiles dataset streamed from an octree, refined by screen-space error as the camera moves. City of Toronto 3D massing, Open Government Licence

A field of a hundred and fifty rigged fox figures, each at a different point in a walk or a run — A hundred and fifty rigged figures, posed on the GPU and drawn as one instanced call, each crossing the field on its own. Fox by PixelMannen and tomkranis, CC-BY 4.0

A car crossing a railed viaduct over a forested valley, mountains beyond — The circuit is carried over the low ground rather than routed round it: a walled causeway, a viaduct across the valleys, a bore through the hills. GLinting Steel

Inside a Greek temple, looking down the inner colonnade at a painted coffered ceiling — A reconstruction walked from the inside: baked cameras, a painted ceiling, and light through the colonnade. the Parthenon model, CC0

A chrome marble on a tilted tiled board of ramps and gaps — **`oglc-marble`** — a generated board, tilted by the player, with the marble rolled by the rigid-body solver. the marble demo

A leather flight helmet with goggles and an oxygen mask, lit from the side — Leather, glass, rubber and painted metal on one model, lit by an image-based probe. FlightHelmet, public domain (CC0)

Every picture on this site is a frame the engine drew. manifest.toml holds the recipe for each one and tools/doc_images.py runs them again; what is in them is credited in ATTRIBUTION.md.

Introduction

OpenGLContext is a 3D engine written in Python on top of PyOpenGL. It opens a window on any of five GUI toolkits, loads glTF 2.0, VRML97, OBJ and 3D Tiles content into a scenegraph, and draws it with a physically based OpenGL 3.3 core-profile renderer — with physics, spatial audio, an overlay UI and a movement model beside it, so that an application is the world you author rather than the plumbing under it. It is also the environment PyOpenGL itself is exercised and taught in: the tutorials and the sample code are a way into OpenGL for people who have not written any.

Install it, then open a model and walk around it:

pip install "OpenGLContext[glfw]"
oglc-view model.glb

The installation notes cover the optional extras — other backends, Draco-compressed glTF, audio playback and video recording — and the viewer page covers what oglc-view can open.

Features

Rendering
- Modern shader pipeline on the OpenGL 3.3 core profile, and a fixed-function pipeline on the compatibility profile
- Physically based materials — a metallic/roughness uber-shader with image-based lighting
- Dynamic shadows from cascaded shadow maps, shared by the core lighting and PBR passes
- Particle effects — fire, smoke, sparks and explosions in one instanced draw
- Instanced geometry, frustum culling and a scenegraph-wide cache, so repeated shapes cost one draw call
- Shader scenegraph nodes, for programs you write yourself
Geometry
- Points and point sprites, lines, polygons and indexed face sets
- Boxes, spheres, cylinders, cones and the NURBS teapot
- NURBS surfaces and curves — rational, trimmed, and tessellated to the distance they are seen from
- Extrusions, lathes, screws, spirals and tubes — swept as vertex arrays, so they draw in either profile, and filled by a constrained Delaunay tessellator that also handles any outline you hand it
- Text — TrueType, as a screen-space texture atlas, 3-D polygonal solids, or 3-D outlines
- glTF meshes — skinned, morph-target and vertex-deformed
- Rigged characters — clips blended together, weapons hung on a hand, and crowds
Worlds
- Terrain — splat-textured height fields, walked, and streamed 3D Tiles datasets with screen-space-error LOD and per-tile colliders
- Vegetation — instanced billboards, grass clumps and near-mesh LOD
- Water — lakes, rivers and choppy weather from one wave field, and water as a medium you are inside
- Roads — a centreline and a cross-section swept into a drivable surface
- Baking an authored world into a streamable 3D Tiles octree, and building an editor to author it in
- All of it at once in GLinting Steel and its track editor
Simulation
- Physics and collision — rigid bodies on the OMI glTF model, gravity zones, triggers, joints and a character controller
- Navigation mesh worked out from the collision mesh, with routes pulled taut through its portals
- Spatial audio — sound placed in the scene on glTF's KHR_audio_emitter model, mixed in numpy
- Timers, interpolators and the event model that carries a change through the scenegraph
Interaction
- Movement modes — examine, fly, walk, swim and FPS mouse-look, with rebindable keys
- Selection and picking, rendered through unique-colour buffers
- Overlay UI — panels, a generated settings screen, a key-binding editor and a console, scaled to the window
- HUD and debug overlay — reticule, meters and messages over a live world, and a debug overlay of frame rate, renderer and audio, plus whatever numbers a subsystem or the application registers
Loading content
- glTF 2.0 and GLB, with the viewer that opens them
- OGC 3D Tiles, streamed from an octree of glTF tiles
- VRML97 worlds, and Wavefront OBJ models
- Quake III BSP levels and PK3 archives, through the twig-bb project
- Textures with Pillow, and system fonts through TTFQuery
Windowing
- GLFW — recommended for core-profile and PBR rendering
- GLUT, Pygame and wxPython
- Qt 6 via PySide through the separate OpenGLContext-qt distribution
- One keyboard, mouse and window event model across all of them
Shipping an application
- Testing what you draw — a hidden GL context in the test process, pytest fixtures that hand one over, and pixel comparison against a baseline
- Session telemetry — a whole session recorded to one file, read back or replayed
- Video recording — the frames a context draws to H.264, on the GPU's own encoder, which today is an NVIDIA card on Linux
- Packaging — a PyInstaller bundle, which the engine ships the hooks for, or a Debian package carrying its own interpreter
- Settings — a renderer option is a field on the context definition, so it has an environment variable for its default, a control on a generated in-game settings screen, and a value the application can store and restore