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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
/*!
# Kiss3d
Keep It Simple, Stupid 3d graphics engine.
This library is born from the frustration in front of the fact that today's 3D
graphics library are:
* either too low level: you have to write your own shaders and opening a
window steals you 8 hours, 300 lines of code and 10L of coffee.
* or high level but too hard to understand/use: those are libraries made to
write beautiful animations or games. They have a lot of feature; too much
feature if you only want to draw a few geometries on the screen.
**kiss3d** is not designed to be feature-complete or fast.
It is designed to be able to draw simple geometric figures and play with them
with one-liners.
An on-line version of this documentation is available [here](http://kiss3d.rs).
## Features
Most features are one-liners.
* WASM compatibility.
* open a window with a default arc-ball camera and a point light.
* a first-person camera is available too and user-defined cameras are possible.
* display boxes, spheres, cones, cylinders, quads and lines.
* change an object color or texture.
* change an object transform (we use the [glam](https://docs.rs/glam/) library
for math operations).
* create basic post-processing effects.
As an example, having a red, rotating cube with the light attached to the camera is as simple as:
```no_run
use kiss3d::prelude::*;
#[kiss3d::main]
async fn main() {
let mut window = Window::new("Kiss3d: cube").await;
let mut camera = OrbitCamera3d::default();
let mut scene = SceneNode3d::empty();
let mut c = scene.add_cube(1.0, 1.0, 1.0);
c.set_color(RED);
let rot = Quat::from_axis_angle(Vec3::Y, 0.014);
while window.render_3d(&mut scene, &mut camera).await {
c.rotate(rot);
}
}
```
This code works on **both native platforms and WASM** without any changes! The `#[kiss3d::main]`
macro and `async` rendering API handle the platform differences automatically:
* **On native**: The async runtime is managed with `pollster::block_on`
* **On WASM**: The async function integrates with the browser's event loop via `requestAnimationFrame`
This approach eliminates the need for platform-specific code or managing different entry points,
making it simple to write truly cross-platform 3D applications.
Some controls are handled by default by the engine (they can be overridden by the user):
* `scroll`: zoom in / zoom out.
* `left click + drag`: look around.
* `right click + drag`: translate the view point.
* `enter`: look at the origin (0.0, 0.0, 0.0).
## Compilation
You will need the last stable build of the [rust compiler](http://www.rust-lang.org)
and the official package manager: [cargo](https://github.com/rust-lang/cargo).
Simply add the following to your `Cargo.toml` file:
```text
[dependencies]
kiss3d = "0.36"
```
## Contributions
I'd love to see people improving this library for their own needs. However, keep in mind that
**kiss3d** is KISS. One-liner features (from the user point of view) are preferred.
## Acknowledgements
Thanks to all the Rustaceans for their help, and their OpenGL bindings.
*/
// TODO: should be denied
extern crate bitflags;
extern crate num_traits as num;
extern crate rusttype;
extern crate serde;
pub extern crate egui;
pub use glamx;
// Re-export the procedural macro and its runtime dependencies
pub use main;
pub use pollster;
pub use wasm_bindgen_futures;
pub use cratepoint_renderer3d;