Cargo

• cargo check: Muestra los errores de compilación sin compilar.
• cargo build --release
• cargo doc --open: Abre la documentación en el navegador.
• cargo install: Instala en user/.cargo/bin un ejecutable, no sirven libs. Con esto podemos hacer “plugins” para cargo, si se llama cargo-something ejecutaríamos cargo something.
• cargo login aaa bbb: son los token de crates.io.
• cargo publish: Antes de debe hacer un commit; y, aparte de los valores por defecto de Cargo.toml, debemos añadir una descripción y una licencia. Otra cosa importante es que no se puede borrar el código de la página, pero podemos evitar que se use determinada versión cargo yank --vers <version> [--undo].

Paquetes:

# Cargo.toml (por defecto)
[profile.dev]
opt-level = 0 # mínimo

[profile.release]
opt-level = 3 # máximo

Un workspace es una forma de agrupar muchos paquetes en el mismo proyecto. De esta manera lo tendremos mucho más ordenado.

Cada paquete tendrá su propia carpeta dentro del proyecto base, y estas tendrán su propio archivo Cargo.toml. En el proyecto base se referirá a sus otros crates de los que depende como miembros, dando su dirección. Un buen ejemplo de esto es gfx-rs.

Para publicar trabajar con un workspace:

• cargo run -p <package>
• cargo test -p <package>

Nota: Tienes que publicarlos en crates.io por separado.

[workspace]
members = [ "adder", "add_one" ]
# Dentro de cada dirección debe haber un paquete válido

# add_one Cargo.toml
[dependencies]
# add_one depende de adder
adder = { path = "../adder" }

Documentación y reexportación

//! Esto es para documentar el archivo

/// `markdown aquí`
/// ```
/// El código que añadamos funcionan como tests
/// ```
/// ```norun
/// Este código de aquí no se ejecuta
/// ```
/// Seciones importantes: ejemplos / panic / error / unsafe

// Rexportación: prevenimos de que el usuario tenga que escribir toda la dirección
pub use direction;

Algunos crates interesantes

Funcionalidades

• rand (docs): genera números aleatorios.
• mint (docs): mates (TODO: Comprobar si es buena).
  • Point2 y Point3
  • Vector2, Vector3 y Vector4
  • Cuaterniones y matrices
  • Ángulos de Euler
• TODO: Mirar nalgebra.

CLI

• clap (docs): Command Line Argument Parser.
• read_input (docs): gestiona el input del usuario (TODO: Comprobar si es buena).
• inquire (docs): alternativa para input de usuario (TODO: Comprobar si es buena).
• crossterm (docs): manipula la terminal (multiplataforma) (TODO: Comprobar si es buena).
• colorful (docs): utiliza colores para el output.

Audio

• cpal (docs): control low level para salida y entrada de audio (multiplataforma, incluso WASM). Diferentes backends: ASIO (Windows) y JACK (Linux).
• rodio (docs): usa cpal para la reproducción de .mp3, .wav, .flac… (TODO: Comprobar si es buena).

Gráficos y GPU

• winit (docs): creación de ventanas multiplataforma, eventos, monitores, etc.
• WGPU (docs): una nueva API con diferentes backends (OpenGL ES, Vulkan, etc).
• Vulkano (docs): wrapper sobre la API de Vulkan.
• Glium (docs): wrapper seguro sobre la API de OpenGl (Actualmente no está mantenido por el autor original).
• Raylib (docs): bindings para la librería en C de Raylib.
• SDL2 (docs): bindings para la librería en C de SDL2.

Game engines

• Bevy (docs, site): sencillo, modular y orientado a datos (Todavía en desarrollo).
  • Usa wgpu, winit, glam-rs (mates 3D para juegos), spirv-reflect (reflejos?)
  • 2D y 3D.
  • Multiplataforma.
  • Sencillo para principiantes y flexible para avanzados.
  • Orientado a datos.
  • Modular: cambia lo que no te gusta.
  • Rápido: la aplicación se ejecuta rápido, y cuando es posible, en threads.
  • Productivo: hot reloading y tiempos de compilación cortos.
  • Sonido, escenas, ECS, GUI…
• Piston (docs): muy modular (es una colección de librerías), y por ello también muy amplio y con muchas características.
  • Gráficos y animación en 2D y 3D.
  • GUI
  • AI
  • Sonido y música
  • Network
• ggez (docs)
  • Abstracción del sistema de archivos: abrir carpetas (o .zip) para cargar recursos.
  • Eventos de teclado y ratón (con callbacks).
  • Cargar archivos .ogg, .wav y .flac gracias a rodio.
  • Renderizado gracias a gfx-rs.
  • Opciones avanzadas de gráficos: shaders, sprites batches, render targets.
  • Matemáticas de mint.
  • Renderizado de fuentes TTF con rusttype y glyph_brush.
  • Usa un archivo de configuración.
  • Funciones de control de tiempo, FPS…
  • Para Windows y Linux (puede que funcione en Mac).
  • No tiene: físicas, animación, GUI, manejo de assets, AI, ECS, Networking.
• macroquad (docs): sencillo (inspirado por Raylib)
  • Multiplataforma (incluso para WASM y Android/iOS con un comando)
  • Renderizado 2D eficiente
  • GUI inmediata incluida
  • Mínimas dependencias: se compila en 16s