Legion Low Level Rendering Interface provides a graphics API agnostic rendering interface with minimal CPU overhead and low level access to verbose GPU operations.

Overview

legion logo banner License-MIT Discord

Legion-LLRI

Legion-LLRI, or “Legion Low Level Rendering Interface” is a rendering API that aims to provide a graphics API agnostic approach to graphics development.

LLRI is designed as a low overhead API that helps developers write graphics API / platform agnostic code without the typical limitations of higher level abstractions.

Supported APIs

  • Vulkan
  • DirectX 12
  • MoltenVK

Documentation

Learn more about how to get started, or about how the API works in-depth through our docs: https://docs.legion-engine.com/llri/.

Contributing

Please read CONTRIBUTING.md for details on our code of conduct, and the process for submitting pull requests to us.

Authors

See also the list of contributors who participated in this project.

License

This project is licensed under the MIT License - see the LICENSE file for details

Issues
  • C++ code analysis GitHub action

    C++ code analysis GitHub action

    Enables the standard GH analysis action for LLRI.

    The build file generates vcxproj files using CMake because the analysis auto build workflow doesn't currently accept CMake on Windows.

    The analysis currently only runs on Windows because both llri-dx and llri-vk are built on Windows, which is sufficient because the code between platforms doesn't change.

    feature automation 
    opened by LeonBrands 1
  • add a GH action that updates the copyright year

    add a GH action that updates the copyright year

    Is your feature request related to a problem? Please describe. Copyright is described on a per-file basis, with a starting and current year - A GitHub action should keep the current year updated by running on a yearly basis.

    Describe the solution you'd like Integrate https://github.com/FantasticFiasco/action-update-license-year into the repo's actions, configured in such a way that it checks every source file for the copyright notice.

    feature automation 
    opened by LeonBrands 1
  • Allow for device_desc::adapter == nullptr

    Allow for device_desc::adapter == nullptr

    Simplify applications that don't require elaborate adapter selection by allowing device creation without an adapter, in such a way that createDevice() will simply select the default adapter (enumerateAdapters()[0]).

    feature 
    opened by LeonBrands 1
  • Task/organize deps

    Task/organize deps

    This PR reorganizes the project structure to provide a more out-of-the-box usable library. The PR changes the project structure to be as follows:

    root/
    	include/		- Header files
    	lib/			- Lib files
    	deps/			- Dependencies (must be included & linked against)
    	legion/			- Source code
    	applications/		- Executables (sandbox, unit tests, samples)
    		deps/		- Common dependencies for (sample) applications. Not required for LLRI
    		samples/	- Example API usage
    	binaries/		- Project build files (local)
    

    The PR also includes two samples: 000_hello_llri and 001_validation which introduce the basic core concepts of LLRI. The vast majority of files changed are moved dependencies but the project setup and the samples should be reviewed.

    feature 
    opened by LeonBrands 1
  • Feature/validation callback

    Feature/validation callback

    This PR introduces the validation message callback. This callback can be used to receive messages from both the LLRI API and the internal API (Vulkan/DirectX).

    To accommodate for this, all API functions have been split into a pre-implementation function (llri_impl.hpp) where validation can be applied, and their implementation functions (impl_function()) which get implemented for each API. To prevent this feature from introducing potential performance overhead, the pre-implementation functions are inlined, and the feature introduces the LLRI_ENABLE_VALIDATION and LLRI_ENABLE_INTERNAL_API_MESSAGE_POLLING preprocessor flags that can help prevent LLRI from running unneeded checks in release builds.

    Other than those two flags, the feature introduces:

    1 new structure

    • validation_callback_desc Which is passed into the instance_desc structure and allows the user to pass a callback function and a user data pointer. Passing a callback is optional, the API will simply not forward callback messages if no callback function is passed.

    2 new enum types

    • validation_callback_severity Describes the severity of the message (Verbose, Info, Warning, Error, Corruption)
    • validation_callback_source Describes the source of the message (LLRI Validation or the InternalAPI)

    All enum types come with matching to_string() functions for ease of debugging.

    1 new function pointer

    • validation_callback Is used to receive callback messages from LLRI and its internal API. It passes a severity, source, message, and optionally userdata.
    feature 
    opened by LeonBrands 1
  • Removed legion shader preprocessor build

    Removed legion shader preprocessor build

    This PR removes the legion shader preprocessor build in applications because the build was very bloated (taking over the vast majority of the repo's stats/info) and it'll likely need to undergo significant changes before being reintroduced

    feature 
    opened by LeonBrands 1
  • llri::Instance

    llri::Instance

    This subfeature introduces the Instance as the core structure of the LLRI API. The subfeature brings the following:

    1 new handle:

    • llri::Instance is responsible for the creation of all API objects in the application. It's the equivalent of VkInstance, DXGI_Factory and an OpenGL Context.

    3 new structures:

    • llri::InstanceExtension Describes an optional instance extension. These extensions may or may not be available depending on the available internal API, and the system's hardware and drivers.
    • llri::APIValidationEXT An instance extension that enables API validation. API validation causes performance overhead but is useful in debugging scenarios.
    • llri::GPUValidationEXT An instance extension that enables GPU validation. GPU validation causes significant performance overhead but can be useful when debugging shaders or synchronization issues.

    1 new enum type:

    • llri::InstanceExtensionType Describes the kind of instance extension. This value is used in InstanceExtension and is used internally to recognize the extension type and cast InstanceExtension::data to the correct underlying type

    3 new functions:

    • llri::createInstance() Creates an instance handle with the given instance description. Passed extensions are created/enabled internally.
    • llri::destroyInstance() Destroys the instance and its internal extension resources. This does not include resources created through the instance, that responsibility remains up to the user.
    • llri::queryInstanceExtensionSupport() Queries the support of the given extension. Returns true if the extension is supported, and false if it isn't.
    feature 
    opened by LeonBrands 1
  • Task/tests adapter selection

    Task/tests adapter selection

    Unit tests now support a cmake flag that override the adapters that the tests should run on. This enables local configurations to only run on the selected GPU(s), which will be desirable for localised runners who might not wish to give up all their system resources.

    If no GPU is specified in CMake, all GPUs are selected like normal.

    feature automation building unit tests 
    opened by LeonBrands 0
  • Rename to Rythe-LLRI

    Rename to Rythe-LLRI

    Updates names, links, and moves all source code from /legion/engine/ to /src/

    note: the license badge doesn't work on my preview but I believe that's because I updated the repo name after I updated README.md, I assume it'll re-parse on merge

    documentation llri-api 
    opened by LeonBrands 0
  • Native pointers

    Native pointers

    Introduce functions for each object type that enables the user to get the native pointers of underlying types. This allows users to integrate with libraries that expect native pointers. Users can then use llri::getImplementation() to cast the resulted pointers to the correct types.

    feature llri-api 
    opened by LeonBrands 0
  • Use compile time hashed strings in impl_createInstance()

    Use compile time hashed strings in impl_createInstance()

    in createInstance(), llri-vk uses raw strings in the unordered_set, switching to compile time hashed strings would result in a minor performance improvement

    llri-vk improvement 
    opened by LeonBrands 0
  • LGTM and CodeCov setup

    LGTM and CodeCov setup

    opened by GlynLeine 4
  • Comment consistency

    Comment consistency

    There's no consistent style in which comments are written in the repository. Establish a consistent rule for comments (we could for example require standard English rules - start with a capital letter, end with a dot), and enforce the ruling throughout the codebase.

    improvement 
    opened by LeonBrands 0
Cross-platform, graphics API agnostic, "Bring Your Own Engine/Framework" style rendering library.

bgfx - Cross-platform rendering library GitHub Discussions Discord Chat What is it? Cross-platform, graphics API agnostic, "Bring Your Own Engine/Fram

Бранимир Караџић 11.8k Jul 2, 2022
Low Level Graphics Library (LLGL) is a thin abstraction layer for the modern graphics APIs OpenGL, Direct3D, Vulkan, and Metal

Low Level Graphics Library (LLGL) Documentation NOTE: This repository receives bug fixes only, but no major updates. Pull requests may still be accept

Lukas Hermanns 1.4k Jul 2, 2022
A modern cross-platform low-level graphics library and rendering framework

Diligent Engine A Modern Cross-Platform Low-Level 3D Graphics Library Diligent Engine is a lightweight cross-platform graphics API abstraction library

Diligent Graphics 2.4k Jun 29, 2022
An immediate-mode, renderer agnostic, lightweight debug drawing API for C++

Debug Draw An immediate-mode, renderer agnostic, lightweight debug drawing API for C++. License This software is in the public domain. Where that dedi

Guilherme Lampert 433 Jun 25, 2022
Pathway is an Android library that provides new functionalities around the graphics Path API.

Pathway is an Android library that provides new functionalities around the graphics Path API.

Romain Guy 98 Jun 28, 2022
A low-level, cross-platform GPU library

vgpu is cross-platform low-level GPU library. Features Support for Windows, Linux, macOS. Modern rendering using Vulkan and Direct3D12. Dependencies U

Amer Koleci 5 Jun 8, 2022
NVRHI (NVIDIA Rendering Hardware Interface) is a library that implements a common abstraction layer over multiple graphics APIs

NVRHI Introduction NVRHI (NVIDIA Rendering Hardware Interface) is a library that implements a common abstraction layer over multiple graphics APIs (GA

NVIDIA GameWorks 381 Jun 19, 2022
Deno gl - WIP Low-level OpenGL (GLFW) bindings and WebGL API implementation for Deno.

deno_gl WIP Low-level OpenGL (GLFW) bindings and WebGL API implementation for Deno. Building Make dist directory if it doesn't exist. Build gl helper

DjDeveloper 14 Jun 11, 2022
Software ray tracer written from scratch in C that can run on CPU or GPU with emphasis on ease of use and trivial setup

A minimalist and platform-agnostic interactive/real-time raytracer. Strong emphasis on simplicity, ease of use and almost no setup to get started with

Arnon Marcus 44 May 18, 2022
A terminal-based graphics library for both 2D and 3D graphics.

TermGL A terminal-based graphics library for both 2D and 3D graphics. Written in C, created for terminals supporting ANSI escape codes. Table of Conte

null 201 Jun 26, 2022
kaun is a replacement for löve's built-in love.graphics module intended for 3D graphics

kaun kaun is a replacement for löve's built-in love.graphics module intended for 3D graphics. It is a Lua module you can require from a shared library

Joel Schumacher 4 Apr 5, 2021
This repo contains the DirectX Graphics samples that demonstrate how to build graphics intensive applications on Windows.

DirectX-Graphics-Samples This repo contains the DirectX 12 Graphics samples that demonstrate how to build graphics intensive applications for Windows

Microsoft 4.6k Jun 27, 2022
Vire is a C++ voxel rendering engine. It is written in C++14 and uses OpenGL for graphics.

Vire Vire is a C++ voxel rendering engine. It is written in C++14 and uses OpenGL for graphics. Downloads If you'd just like to just download and try,

null 35 Jun 25, 2022
Vulkan Minimal Hybrid Rendering

Vulkan Minimal Hybrid Rendering A minimal hybrid rendering sample using ray query Features Rasterization Raytraced shadow Environment Vulkan SDK 1.2.1

Yuki Nishidate 7 Aug 16, 2021
Dear PyGui 3D Engine (early development) and Graphics API demos.

Marvel This repo is the working location of the eventual Dear PyGui 3D Engine. It also contains several single file examples of creating a triangle wi

Jonathan Hoffstadt 79 Jun 29, 2022
SPIRV-Reflect is a lightweight library that provides a C/C++ reflection API for SPIR-V shader bytecode in Vulkan applications.

SPIRV-Reflect SPIRV-Reflect is a lightweight library that provides a C/C++ reflection API for SPIR-V shader bytecode in Vulkan applications. SPIRV-Ref

The Khronos Group 407 Jun 18, 2022
ORE (OpenGL Rendering Engine) is a rendering engine developed for my college minor project assessment.

ORE (OPENGL RENDERING ENGINE) What is ORE? ORE(OpenGL Rendering Engine) is a rendering engine with great and easy to use UI that allows the user to lo

HARSHIT BARGUJAR 4 Dec 20, 2021
Lightweight and modular C++11 graphics middleware for games and data visualization

Magnum — Lightweight and modular C++11/C++14 graphics middleware for games and data visualization Looking for an open-source library that gives you gr

Vladimír Vondruš 4.1k Jul 3, 2022
Brand new engine with new and QoL features. Grafex is Psych engine with some additions and Better graphics

Friday Night Funkin' - Graphex Engine Credits: Grafex Mod aka Psych Graphic Rework: Xale - Lead Coding, Artist PurpleSnake - Second Coder Psych Engine

Xale 2 Jun 27, 2022