rin

PBR Materials

rin comes with physically based rendering materials based on a roughness/metallicness workflow making it easy to import assets like 3d models and materials created for other engines like unreal engine or unity.

rin also easily supports the most common kinds of lights and shadows including soft shadows.

Native blender import

With rin you can import Blender files natively allowing to load geometries, animations, rigid bodies, skeletons and skinning, materials, lights, shadow maps and more, effectively allowing to use blender as a 3D game editor.

Rust

rin is based on Rust, a systems language that provides elegant solutions to problems like error handling or memory management. Among other many features, Rust enums or iterators allow to implement certain designs in a much more concise way than in other languages and make certain tasks much easier and readable without compromising performance.

Easy to use external dependencies

Rust, makes it super easy to use any external dependency. Just add the name of the crate (Rust's libraries) you want to use to the Cargo.toml config file in the root of your project and the next time you compile the crate will be downloaded and compiled with your application

You can find thousands of crates in the official rust repository, crates.io

GUI

ringui provides a nice and fast set of gui elements that in combination with rin's event system allows to quickly adjust parameters of your application.

Every rin addon can easily provide it's own gui allowing to easily adjust it's parameters at runtime without recompiling

Postprocessing effects

rin comes with many useful postprocessing effects like fxaa, bloom, ambient occlusion, depth of field or tonemapping.

Every postprocessing effect can be enabled and tweaked at runtime from the corresponding gui.

Profiling tools

rin has several tools to make debugging and profiling complex applications easier. For example for each system in the application, rin shows how much time it takes to run it in the cpu and in the gpu making it really easy to find what part of an application is making things slow. It also allows to quickly disable individual systems at run time which among other things allows to see the effects on performance of every individual system.

rin also allows to export statistics to the chrome tracing format and others in the future.

Inspector

rin's inspector, among other debugging tools, allows to see in real time the values of any component of every entity in the application. From the gui you can look for any value and even create graphs of how the values change over time with just one mouse click.

Memory and thread safety

Rust is a memory and thread safe language which means that you won't ever see again a segmentation fault or have thread data race issues. Multithreaded programming to speed up some tasks is easy and the compiler and Rust data sharing structures automatically take care of making sure that there's no wrong multithread or memory accesses.

Powerful event system

Rin provides an event management system based on ideas from reactive programming and rust iterators which allow to transform events into other types, filter them by certain conditions, debug and process the events in an easy safe and readable way.

Safe and fast OpenGL abstractions

Use OpenGL without ever leaking it's state. Rin tracks the OpenGL state internally and only does the minimum changes possible when you set any properties from anywhere. No need for push/pops or guards of any kind, just set the properties you want to get a new renderer and draw with it.

Modular

Rin is divided in several modules that can be disabled and even used independently.

If your application for example doesn't use video that feature can be disabled so compilation is faster and binaries are smaller

Additionally, modules can be used separately: you don't need to use the full rin crate but you can import whatever modules you are going to use.

Some modules also have features that can be enabled from the application cargo config file allowing even more fine grained modularity

Performance

Rin optimizes processes like rendering behind the scenes without you having to care about the details. When adding new models to a scene, rin knows which of those geometries are the same and uses instanced drawing to reduce the number of draw calls.

By using OpenGL AZDO (approaching zero overhead) techniques, where available, rin reaches a performance similar to that of newer rendering APIs

We also plan to add support for Vulkan and/or WebGPU and other rendering APIs in the near future

OOP or ECS

Choose between object oriented programming, for smaller projects and quick prototypes or an entity component system approach also known as data driven programming, for larger or more complex projects.

Systems dependencies

When working with ECS rin can export a visualization of every system running at any moment and their dependencies.