Included in rin


High level GL module that contains things like the gl renderer, lights, materials, shadowmaps or facilities to draw in 2d using OpenGL. It uses glin under the hood to allow to create GL objects like textures, glsl programs, VAOs, etc.


This module is responsible for running the application loop and call the user callbacks when using the app template. IT's not needed if you don't use the ApplicationCallbacks trait to receive callbacks from the window events and instead use the loop template.


The graphics module caontains all shorts of 2d and 3d graphics primitives that allow to get a mesh with that primitive to then draw it using a renderer engine. It also contains cameras, utlities to use transformation matrices, to load images from an image file into raw pixels or to load ttf fonts into memory.


Math utilities mostly oriented towards working with graphics. Most of the types and functions in this module are re-exports from other crates:

  • angle: a crate to safely work with angles by defining types for radians and degrees and utilities to work with angles and go between the different units.

  • nalgebra a crate for linear algebra

Since nalgebra is really general purpose algebra rinmath uses it through na which defines short aliases and constructor functions to create nalgebra types.


General utility functions and types


Video files player and devices grabber. Right now it's dependent with gl and gstreamer. It's disabled by default when using the rin module but can be enbaled with the video feature or just manually including it if you are including modules separately. It needs the gstreamer sdk to work in platforms other than linux where gstreamer is usually included by default.


Contains the window type that allows to create one or more windows from an application. It also contains all the types related to window events like mouse or key presses and some utilities to work with them using rinevents.


Events system based on ideas from reactive programming and rust iterators. Allows to use a push or poll model when working with events. Usually an event generator will provide an event stream. Streams follow a push model and can be filtered, mapped and in general use all the same functions you would apply to a Rust iterator. An stream can be turned into a Property which is a variable that tracks the last value of the source stream from which it was created or into an iterator which follows a pull model.


Types and functions to work with colors.

External crates


GUI crate that provides basic gui elements like sliders, buttons, toggles, graphs, button groups, text boxes or tabs. Mostly oriented to adjust application parameters in runtime for development purpose rather than a final user gui.


This module can apply post production filters like bloom, fxaa antialiasing or tonemapping to a texture. Optionally it can provide [ringui]( parameters so it can be adjusted through a gui.


glin is the low level gl abstraction behind ringl. It's an easy to use, light OpenGL 3+ wrapper

glin aims to be a mostly bindless, simple wrapper over opengl that simplifies and provides a safe api for opengl without aiming to cover every possible case but instead making it easy to use unsafe calls in combination with the safe api when one needs to use extensions or any opengl api that is not covered (yet).


Low level access to the blender file format. The blender file is pretty much a dump of the memory of the program while it's running and it includes an index of that memory. This crate allows to access that index and the objects included in the file. It allows to access anything in the file and doesn't define high level structures.


Uses the blender crate to access the most common objects in a blender file and creates a simple representation of them as rust structs. It parses things like lights, models, armatures and all the treansformation hierarchy. It also provides functionality to animate models with armatures and it's graphics API agnostic.


Uses rinblender to bring all the models, lights and transformation in a scene into opengl objects that can be directly drawn using ringl. If you want to draw a full scene this is probably the crate you want to use.