1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

#![feature(const_fn)]

//! # What is this?
//!
//! [![crates.io](https://img.shields.io/crates/v/luminance.svg)](https://crates.io/crates/luminance)
//! ![License](https://img.shields.io/badge/license-BSD3-blue.svg?style=flat)
//!
//! `luminance` is an effort to make graphics rendering simple and elegant. The aims of `luminance` are:
//!
//! - making **unsafe** and **stateful** *APIs* (e.g. **OpenGL**) **safe** and **stateless**;
//! - providing a simple API; that is, exposing core concepts without anything extra – just the bare
//!   stuff;
//! - easy to read with a good documentation and set of tutorials, so that new comers don’t have to
//!   learn a lot of new concepts to get their feet wet.
//!
//! # Safety disclaimer
//!
//! In strict terms, luminance is not safe, because it depends on several assumptions (OpenGL
//! context, mostly). However, most of the rest of the library is safe – it’s way safer than issuing
//! raw OpenGL calls. Work is yet to decide how to cope with those safety problems, but in the end,
//! it’ll end up in luminance when time comes.
//!
//! # What’s included?
//!
//! `luminance` is a rendering framework, not a 3D engine. As so, it doesn’t include stuff like
//! lights, materials, asset management nor scene description. It only provides a rendering framework
//! you can plug in whatever libraries you want to.
//!
//! > There are several so-called 3D-engines out there on [crates.io](https://crates.io). Feel free
//! > to have a look around.
//!
//! ## Features set
//!
//! - **buffers**: **buffers** are way to communicate with the *GPU*; they represent regions of memory
//!   you can write to and read from. There’re several kinds of buffers you can create, among *vertex
//!   and index buffers*, *shader buffer*, *compute buffer*, and so on and so forth…;
//! - **framebuffers**: **framebuffers** are used to hold *renders*. Each time you want to perform a
//!   render, you need to perform it into a framebuffer. Framebuffers can then be combined with each
//!   other to produce nice effects;
//! - **shaders**: `luminance` supports five kinds of shader stages:
//!   + tessellation control shaders;
//!   + tessellation evaluation shaders;
//!   + vertex shaders;
//!   + geometry shaders;
//!   + fragment shaders;
//! - **vertices, indices, primitives and tessellations**: those are used to define a shape you can
//!   render into a framebuffer;
//! - **textures**: **textures** represent information packed into arrays on the GPU, and can be used
//!   to customize a visual aspect or pass information around in shaders;
//! - **blending**: **blending** is the process of taking two colors from two framebuffers and
//!   mixing them between each other;
//! - and a lot of other cool things like *GPU commands*, *pipelines*, *uniform interfaces* and so
//!   on…
//!
//! # Current implementation
//!
//! Currently, luminance is powered by OpenGL 3.3. It might change, but it’ll always be in favor on
//! supporting more devices and technologies – a shift to Vulkan is planned.
//!
//! # Windowing
//!
//! `luminance` does not provide a way to create windows because it’s important that it not depend
//! on windowing libraries – so that end-users can use whatever they like. Furthermore, such
//! libraries typically implement windowing and events features, which have nothing to do with our
//! initial purpose.
//!
//! > Keep in mind that you could, in theory, create a context for luminance on your own. Currently,
//! > this is highly unsafe, as you must only allocate the right context (an OpenGL 3.3, Core
//! > profile) and leave OpenGL calls to luminance. Some work is planned to give luminance a backend
//! > interface and make the whole thing cleaner and safer.
//!
//! # How to dig in?
//!
//! `luminance` is written to be fairly simple. The documentation is very transparent about what the
//! library does and several articles will appear as the development goes on. Keep tuned! The
//! [online documentation](https://docs.rs/luminance) is also a good link to have around. As a start
//! off, you need to have a look at the `pipeline` module.

extern crate gl;

pub mod blending;
pub mod buffer;
#[macro_use]
pub mod framebuffer;
#[macro_use]
pub mod gtup;
pub mod linear;
pub mod pipeline;
pub mod pixel;
pub mod shader;
pub mod tess;
pub mod texture;
pub mod vertex;