cococry/leif
Leif
Leif is an OpenGL-backed immediate mode graphical user interface library and graphics rendering framework. It provides a lightweight control flow where layouts and components are rebuilt every frame without retaining an internal scene graph, backed by hardware-accelerated graphics.
The framework utilizes GPU-accelerated batch rendering to draw high volumes of primitives efficiently by grouping geometry into single vertex buffers. Developers can bypass standard rendering wrappers to access the underlying renderer directly, drawing raw graphics and custom geometry alongside standard interface components.
Additional capabilities include event-driven input polling for capturing operating system mouse and keyboard states, and a stateless property modification system for dynamically configuring visual attributes each frame. The architecture exposes internal component data and rendering pipelines directly, allowing custom elements to be built client-side.
Features
- Batch Rendering - Utilizes GPU-accelerated batch rendering to draw high volumes of primitives efficiently by grouping geometry into single vertex buffers.
- Immediate Mode UI Libraries - Provides an OpenGL-backed immediate mode graphical user interface library for rendering interactive windows and widgets.
- C++ Rendering Libraries - Provides a low-level visual component library in C++ offering direct access to underlying rendering contexts and custom batch graphics.
- Custom Graphics Rendering - Utilizes an exposed batch rendering system to draw non-interface custom graphics alongside standard graphical elements.
- Custom Renderable Interfaces - Enables building custom UI elements client-side by accessing the exposed internal state and rendering pipeline directly.
- Graphics Rendering APIs - Allows developers to bypass standard rendering wrappers and interact with the underlying graphics API directly.
- OpenGL Canvas Rendering - Builds custom graphical user interfaces powered by modern OpenGL with high-performance batch rendering and direct hardware acceleration.
- Render Loop Execution - Manages graphical interface updates between initialization calls and execution boundaries within the main application loop.
- Direct Block Access - Bypasses standard abstraction layers to let developers draw raw graphics and custom geometry directly using the underlying renderer.
- GPU-Accelerated UI Rendering - Acts as a high-performance interface rendering framework that offloads drawing operations directly to the graphics processing unit.
- Immediate Mode UI Frameworks - Rebuilds layouts and renders user interface components every frame without retaining an internal scene graph.
- Window Initialization Routines - Creates graphical application windows backed by hardware-accelerated rendering contexts for drawing interactive elements.
- Component Property Interfaces - Changes the appearance and property values of individual interface components through a flexible property system.
- Input Event Polling - Captures operating system mouse and keyboard states via event-driven polling during the main application loop.
- Interface Appearance Customizations - Updates the visual appearance of individual elements using a property system that controls every visible attribute.
- Input State Monitors - Monitors keyboard and mouse states through a built-in input handling subsystem to drive interactive application logic.
- Styled Properties - Configures visual attributes and element appearances dynamically through a lightweight property modification system executed each frame.
- User Input Processing - Processes mouse movements, clicks, and keyboard strokes from the operating system to drive interactive application states.
