Crate kiss3d 

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.

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 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:

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 and the official package manager: cargo.

Simply add the following to your Cargo.toml file:

[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.

Re-exports

pub use crate::renderer::point_renderer3d;

pub use glamx;

Modules

builtin

Built-in geometries, shaders and effects.

camera

Camera trait with some common implementations.

color

Common color constants for use with kiss3d rendering functions.

context

wgpu rendering context management.

event

Window event handling.

light

Lighting configuration for 3D scenes.

loader

File loading.

post_processing

Post-processing effects.

prelude

procedural

Procedural mesh generation.

renderer

Structures responsible for rendering elements other than kiss3d’s meshes.

resource

GPU resource managers

scene

Everything related to the scene graph.

text

Text rendering.

window

The window, and things to handle the rendering loop and events.

Attribute Macros

main

Macro to simplify writing cross-platform (native + WASM) kiss3d applications.