All Classes and Interfaces
Class
Description
Template-method base class for modules that enforces the lifecycle state machine.
Base class for all scene implementations.
Base class for engine applications.
Border color used when wrap mode is
WrapMode.CLAMP_TO_BORDER.Phantom type tag for buffer handles.
Writes typed values to a
NativeMemory for GPU buffer upload.Web implementation of
NativeMemory backed by a ByteBuffer.Camera parameters uploaded to the GPU each frame.
Registry of device capabilities.
An immutable list of recorded render commands.
Records render commands into a
CommandList.Comparison function for depth/shadow samplers.
A compiled shader pipeline with reflection metadata.
A shader parameter binding — name, slot index, and type.
Marker interface for all components.
Renders the debug UI overlay using the engine's graphics API.
Typed capability key for querying GPU/backend features and limits.
Marks a class for compile-time discovery.
Central registry of all
Discoverable classes across all modules.Generated per-module registry of
Discoverable classes.JVM-only resource loader for
Discovery.The main engine class.
Configuration for the Engine.
Marks a cross-cutting engine feature for the website.
Container annotation for repeatable
EngineFeature.Marks a package as an engine module for the website.
Engine-wide parameters uploaded to the GPU each frame.
An entity in the scene — just an ID with component storage.
Phantom type tag for scene entity handles.
Marks a class as a website example showcase.
Watches a directory for file modifications and dispatches callbacks.
Accumulator-based fixed timestep
UpdateStrategy.Abstraction over OpenGL 4.5 DSA functions and constants.
OpenGL implementation of
GpuFence using GL sync objects.Well-known names for the built-in global shader parameter blocks.
Registry of global shader parameter blocks.
A registered global param block.
OpenGL implementation of
StreamingBuffer using persistent mapped buffers.A typed GPU buffer backed by a Java record type.
High-level GPU fence for synchronization.
Unified GPU resource lifecycle layer.
Marks a record as a GPU struct, triggering compile-time generation of a
*_NativeStruct class that provides reflection-free StructLayout
registration for all platforms (desktop, web/TeaVM, mobile).The result of creating a graphics backend — bundles the toolkit, window, and device.
Deprecated.
Base class for graphics backend configuration.
Deprecated.
Use backend-specific GraphicsConfig subclasses instead.
Generational opaque handle with a phantom type parameter for compile-time safety.
Minimal platform for headless/testing use.
A render device that does nothing — for testing without a GPU.
Parent-child hierarchy component.
Thread-safe event queue.
GPU buffer layout mode determining alignment rules.
A light is a typed property bag.
No-op
UpdateStrategy for modules whose updates are driven externally.Compiles material properties into shader code and GPU-uploadable data.
Immutable material data — a typed property map that is a component.
Phantom type tag for material handles in the scene.
Pure mesh data — no GPU resources.
A registered mesh in the renderer.
Manages GPU mesh resources: creation, upload, and identity-based caching.
Processes scene transactions and maintains the renderer's internal
representation of entities, transforms, materials, and renderables.
Phantom type tag for mesh handles in the scene.
A loaded 3D model with multiple meshes, materials, and hierarchy.
A node in the model's scene hierarchy.
A mesh + material index pair.
Contract for a managed module with a typed update context.
Central manager responsible for the lifecycle and update orchestration of
Module instances.Represents the lifecycle state of a game module.
General-purpose native library loader.
Result of resolving a native library: the directory containing
extracted binaries/libraries, and helper methods to find them.
Describes a native library/tool to be loaded: name, version, executables,
shared libraries, and optional download URLs per platform.
Platform-agnostic interface for reading and writing native memory.
Marks a record for compile-time metadata and struct layout generation.
A no-op
ShaderCompiler for headless testing.Per-object parameters uploaded to the GPU each draw call.
OpenGL backend factory.
OpenGL graphics configuration.
Default upload strategy: one UBO write + bind per draw call.
Manages pipeline lifecycle with descriptor-based deduplication.
Phantom type tag for pipeline handles.
Frame-based pipeline variant cache with automatic eviction.
Detects the current OS and architecture for native library resolution.
Configures platform-specific services for the engine.
Presentation mode controlling vsync behavior.
Factory for common primitive meshes.
Registry of record metadata populated at compile time by the
@NativeStruct
annotation processor.Describes one record component: its name, type, and an accessor function
that extracts the value from a record instance.
Tracks staleness relative to a
Versioned container.Builds StructLayouts via reflection at runtime.
Policy for handling dependent modules when a module is removed.
A resolved renderable: mesh GPU resources + pipeline + binding map.
All possible GPU commands as pure data records.
Low-level backend interface for GPU resource management and command execution.
The single public entry point for all rendering operations.
Three-layer render state resolution: defaults < material < forced.
Manages render target lifecycle: creation, resize, and pooling.
Phantom type tag for render target handles.
Generic resource registry combining a HandlePool with native resource tracking.
Tracks native resource lifecycle statistics: live totals and per-frame operation counters.
A texture paired with its sampler configuration.
Describes a GPU sampler configuration.
Manages sampler lifecycle with descriptor-based deduplication.
Phantom type tag for sampler handles.
Default scene type — hierarchical scene graph.
Provides the Renderer access to drain transactions from a scene.
Saves RGBA8 framebuffer data as PNG.
Desktop implementation of
NativeMemory backed by a MemorySegment.Pre-compiled shader bytecode (SPIRV).
Compiles shader source code to target-specific output (GLSL, SPIRV, WGSL).
Compiled shader result with code per entry point and optional binding metadata.
Describes an entry point to compile.
Broad categories for shader parameters.
Discovered shader parameter with name, binding slot, and category.
Manages shader compilation via Slang (native FFM or process fallback).
Generates Slang interface + implementation for material parameters.
Generates Slang interface + implementation blocks for shader parameter access.
Entry type for reflective construction.
Loader for .slang shader source files.
Raw Slang shader source loaded from a file.
Generates Slang struct source code from Java records.
A streaming buffer for per-frame data uploads.
A write function that serializes a record to native memory at a given offset.
Raw texture data — pixels + metadata.
Pixel format — extensible via interface pattern.
Standard texture property keys for materials.
Manages GPU texture resources: upload, identity-based caching, and material texture binding.
Phantom type tag for texture handles.
Logging decorator for
WgpuBindings.A transaction represents a change that occurred in the scene.
Multi-consumer transaction bus with per-subscriber filtering and double-buffered swap.
Spatial transform: position, rotation, scale.
Marks a class as a tutorial for the website.
Manages uniform buffer creation, layout computation, and per-frame/per-object upload.
Strategy that determines when and how module updates are fired.
Strategy for uploading scene data to GPU and issuing draw commands.
Variable timestep
UpdateStrategy that fires exactly one update per advance call.Thread-safe versioned container.
Phantom type tag for vertex input handles.
Defines a rectangular region of the render target to draw into.
Abstraction over Vulkan functions and constants.
Describes a render pass attachment.
Result of device creation — includes the device handle.
Creates an image without a view (used for depth buffers, etc.).
Result of instance creation — includes the instance handle.
Describes a subpass dependency.
Vulkan backend factory.
Creates a Vulkan surface from a VkInstance handle and a native window handle.
Vulkan graphics configuration with backend-specific settings.
Preferred swapchain surface format.
Identity-based cache with weak reference keys and automatic cleanup.
WebGPU backend factory.
WebGPU graphics configuration.
Abstraction over WebGPU native bindings.
Describes a bind group entry for buffer binding.
Describes a bind group layout entry.
Types of bind group entry resources.
Types of bind group layout entries.
Describes a color attachment for a render pass.
Describes a depth/stencil attachment for a render pass.
Device limits queried from the GPU.
Describes a render pass.
Describes a render pipeline.
Describes stencil face state.
Describes a vertex attribute.
Describes vertex buffer layout for pipeline creation.
WebGPU render device backed by
WgpuBindings.WebGPU implementation of
StreamingBuffer.Describes window creation parameters.
Platform-specific surface information for WebGPU/Vulkan surface creation.
Asset source that reads from a ZIP/archive file.
GraphicsConfigimplementations directly instead.