v5.5

.github/workflows/ci.yml

@@ -8,8 +8,8 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/cache@v2
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
         with:
           path: |
             ~/.cargo/bin/
@@ -26,31 +26,7 @@ jobs:
         run: git submodule init; git submodule update
       - name: Install alsa, udev, glfw3, sdl, and wayland
         run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libglfw3-dev libwayland-dev libsdl2-dev
-      - name: Run doc tests with all features (this also compiles README examples)
-        run: cargo test --doc --all-features
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            target/
-          key: ubuntu-latest-cargo-build-stable-${{ hashFiles('**/Cargo.toml') }}
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          components: rustfmt, clippy
-          override: true
-      - name: Setup git submodules
-        run: git submodule init; git submodule update
-      - name: Install alsa, udev, glfw3, sdl, and wayland
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libglfw3-dev libwayland-dev libsdl2-dev
-      - name: Run clippy
-        run: cargo clippy --workspace --all-targets --all-features
-      - name: Check format
-        run: cargo fmt --all -- --check
+      - name: Clone latest GLFW3
+        run: git clone https://github.com/glfw/glfw; cd glfw; mkdir build; cd build; cmake ..; make -j$(nproc); sudo make install; cd ../..;
+      - name: Run doc tests (this also compiles README examples)
+        run: cargo test --doc

.gitignore

@@ -1,4 +1,4 @@
-/target
+target
 **/*.rs.bk
 Cargo.lock
 /.vscode

.gitmodules

@@ -1,3 +1,5 @@
 [submodule "raylib-sys/raylib"]
 	path = raylib-sys/raylib
 	url = https://github.com/raysan5/raylib
+	commit = "5.5"
+	shallow = true

CHANGELOG.md

@@ -1,6 +1,26 @@
 # raylib-rs Changelog
 
-## 3.7.0 (WIP)
+## 5.7.0
+- More improved ergonomics
+- REFACTOR: Everything that interfaces with `raylib-sys` **has to use mint vectors** because as it has the most common supported interface type in the rust ecosystem. (tl;dr Replaced `ffi::Vectors -> mint::Vectors`)
+- REFACTOR: Everything that interfaces with raylib safe bindings will often **take as input mint vectors but output/store glam-rs vectors**(storing them in Camera, Mesh, Boundingbox, etc), This can easily be swapped out. (tl;dr Replaced: `math::core::Vectors -> glam::Vectors`. glam Matrix and Quat however are incompatible so these stay as is)
+	- BREAKING: Code that uses `Vector4` constructors break, instead use `Vector4::new()
+- REFACTOR:  `Camera3D` ported methods in favor of calling ffi for easier maintenance reasons
+- REFACTOR: trace_log from needing to be on the RaylibHandle and take &self
+- MOVED: `color.rs` to `raylib-sys` because having 2 versions of this simple structure is pointless
+- MOVED: `Rectangle` to `raylib-sys` because having 2 versions of this simple structure is pointless
+- REMOVED: needless `target_os = windows` for rlgl getting&setting matrix functions
+- BUGFIX : `build.rs` gen_utils function generated the `util_log.c` as `rgui`making raygui not work
+- Removed: Removed imgui from being a feature on `raylib-sys`, instead check [imgui example](https://github.com/raylib-rs/raylib-rs/blob/unstable/samples/imgui.rs) for integration
+## build script changes:
+- Blacklist Vector2, Vector3, Vector4, Matrix, Quaternion, Rectangle, Color from generating in bindgen as they are replaced by mint and manual implementations
+- BUGFIX: Fixed bug where `utils_log` compiled as "rgui" making the rust build fail in some cases
+- Prevent android builds from turning on GLFW flags
+- Added/exposed various feature flags
+- Invert `bindgen` feature flag to `nobindgen` since its a more saner default
+
+
+## 3.7.0
 
 - [core] ADDED: LoadVrStereoConfig()
 - [core] ADDED: UnloadVrStereoConfig()

Cargo.toml

@@ -1,3 +1,4 @@
 [workspace]
 members = ["raylib", "raylib-sys"]
 exclude = ["raylib-test", "samples"]
+resolver = "2"

README.md

@@ -1,12 +1,3 @@
-<p align="center">
-
-![rust](https://img.shields.io/badge/rust-1.77+-orange.svg?style=flat-square&logo=rust)
-[![crates.io](https://img.shields.io/crates/v/raylib.svg?style=flat-square)](https://crates.io/crates/raylib)
-[![docs](https://docs.rs/raylib/badge.svg)](https://docs.rs/raylib)
-[![discord](https://img.shields.io/discord/426912293134270465)](https://discord.gg/VkzNHUE)
-
-</p>
-
 <table border="0">
 <tr>
 <td>
@@ -18,7 +9,7 @@
 
 # raylib-rs
 
-raylib-rs is a Rust binding for [raylib](http://www.raylib.com/) 5.0. It currently targets the _stable_ Rust toolchain, version 1.78 or higher.
+raylib-rs is a Rust binding for [raylib](http://www.raylib.com/) **5.5**. It currently targets Rust toolchain version 1.78 or higher.
 
 Please checkout the showcase directory to find usage examples!
 
@@ -30,36 +21,28 @@ Though this binding tries to stay close to the simple C API, it makes some chang
 
 Most development happens over at: https://github.com/raylib-rs/raylib-rs
 
-
-- Resources are automatically cleaned up when they go out of scope (or when `std::mem::drop` is called). This is essentially RAII. This means that "Unload" functions are not exposed (and not necessary unless you obtain a `Weak` resource using make_weak()).
-- Most of the Raylib API is exposed through `RaylibHandle`, which is for enforcing that Raylib is only initialized once, and for making sure the window is closed properly. RaylibHandle has no size and goes away at compile time. Because of mutability rules, Raylib-rs is thread safe!
-- A `RaylibHandle` and `RaylibThread` are obtained through `raylib::init_window(...)` or through the newer `init()` function which will allow you to `build` up some window options before initialization (replaces `set_config_flags`). RaylibThread should not be sent to any other threads, or used in a any syncronization primitives (Mutex, Arc) etc.
-- Manually closing the window is unnecessary, because `CloseWindow` is automatically called when `RaylibHandle` goes out of scope.
-- `Model::set_material`, `Material::set_shader`, and `MaterialMap::set_texture` methods were added since one cannot set the fields directly. Also enforces correct ownership semantics.
-- `Font::from_data`, `Font::set_chars`, and `Font::set_texture` methods were added to create a `Font` from loaded `CharInfo` data.
-- `SubText` and `FormatText` are omitted, and are instead covered by Rust's string slicing and Rust's `format!` macro, respectively.
+Versions normally match Raylib's own, with the minor number incremented for any patches (i.e. 5.5.1 for Raylib v5.5). On occassion, if enough breaking changes are made in between Raylib releases, we'll release a 5.6, which is 5.5 but with breaking changes.
 
 # Installation
 
 ## Supported Platforms
 
-| API    | Windows            | Linux              | macOS              | Web                | Android | 
-| ------ | ------------------ | ------------------ | ------------------ | --------------     | ------- |
-| core   | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x:     |
-| rgui   | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | ❔                 | :x:     |
-| physac | :construction:     | :construction:     | :construction:     | ❔                 | :x:     |
-| rlgl   | :heavy_check_mark: | :x:                | :x:                | ❔                 | :x:     |
+| API  | Windows            | Linux              | macOS              | Web                | Android |
+| ---- | ------------------ | ------------------ | ------------------ | ------------------ | ------- |
+| core | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x:     |
+| rgui | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | ❔                 | :x:     |
+| rlgl | :heavy_check_mark: | :x:                | :x:                | ❔                 | :x:     |
 
 ## Build Dependencies
 
-Requires glfw, cmake, and curl. Tips on making things work smoothly on all platforms is appreciated.
+Requires `glfw`, `cmake`, and `curl`. Tips on making things work smoothly on all platforms is appreciated.
 Follow instructions for building raylib for your platform [here](https://github.com/raysan5/raylib/wiki)
 
 1. Add the dependency to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-raylib = { version = "5.0" }
+raylib = { version = "5.7.0", features = [] }
 ```
 
 2. Start coding!
@@ -82,15 +65,17 @@ fn main() {
 }
 ```
 
-# Tech Notes
+### NixOS
 
-- Structs holding resources have RAII/move semantics, including: `Image`, `Texture2D`, `RenderTexture2D`, `Font`, `Mesh`, `Shader`, `Material`, and `Model`.
-- `Wave`, `Sound`, `Music`, and `AudioStream` have lifetimes bound to `AudioHandle`. 
-- Functions dealing with string data take in `&str` and/or return an owned `String`, for the sake of safety. The exception to this is the gui draw functions which take &CStr to avoid per frame allocations. The `rstr!` macro helps make this easy.
-- In C, `LoadFontData` returns a pointer to a heap-allocated array of `CharInfo` structs. In this Rust binding, said array is copied into an owned `Vec<CharInfo>`, the original data is freed, and the owned Vec is returned.
-- In C, `LoadDroppedFiles` returns a pointer to an array of strings owned by raylib. Again, for safety and also ease of use, this binding copies said array into a `Vec<String>` which is returned to the caller.
-- I've tried to make linking automatic, though I've only tested on Windows 10, Ubuntu, and MacOS 15. Other platforms may have other considerations.
-- OpenGL 3.3, 2.1, and ES 2.0 may be forced via adding `["opengl_33"]`, `["opengl_21"]` or `["opengl_es_20]` to the `features` array in your Cargo.toml dependency definition.
+To use raylib-rs on NixOS there's a provided nix-shell file `shell.nix` at the root of the repo that should get you up and running, which can be used like so:
+
+`nix-shell ./shell.nix`
+
+You'll also need to enable the Wayland feature on the raylib crate:
+
+`cargo add raylib -F wayland`
+
+Contributions are welcome to improve or fix the shell.nix!
 
 ## Building from source
 
@@ -100,78 +85,65 @@ fn main() {
 ### If building for Wayland on Linux
 
 3. Install these packages:  
-`libglfw3-dev wayland-devel libxkbcommon-devel wayland-protocols wayland-protocols-devel libecm-dev`
+   `libglfw3-dev wayland-devel libxkbcommon-devel wayland-protocols wayland-protocols-devel libecm-dev`
+
 ###### Note that this may not be a comprehensive list, please add details for your distribution or expand on these packages if you believe this to be incomplete.
 
 4. Enable wayland by adding `features=["wayland"]` to your dependency definition
 
 ## Cross-compiling using `cross`
 
-The [@rust-embedded](https://github.com/rust-embedded) project provides a handy tool called [`cross`](https://github.com/rust-embedded/cross) that uses docker to cross-compile any cargo project to one of their many [supported platforms](https://github.com/rust-embedded/cross#supported-targets). This tool makes it easy to cross-compile `raylib-rs` for binary distribution (in cases where you are producing a pre-compiled game for example).
-
-### Anything to Windows
-
-Cross-compiling from other platforms to Windows is the simplest. Just build your project with this command instead of the usual `cargo build`:
-
-```sh
-cross build --target x86_64-pc-windows-gnu --release
-```
-
-It should be noted that the resulting exe will likely not run under `wine` due to an issue with Raylib's audio handling.
-
-### Anything to Linux
-
-Cross-compiling from any platform to Linux, or from Linux to Linux requires a little extra work since `raylib-sys` has some system dependencies not provided by `cross`. This following example assumes you are compiling for `x86_64-unknown-linux-gnu`, but it can be any Linux-y triple.
-
-Firstly, a custom build container must be defined. The following `Dockerfile` is the minimum setup for compiling `raylib-sys`:
+Cross compiling with raylib-rs can be made easier with cross. [See more on the wiki](https://github.com/raylib-rs/raylib-rs/wiki/Cross%E2%80%90compiling-using-cross)
 
-```Dockerfile
-FROM rustembedded/cross:x86_64-unknown-linux-gnu-0.2.1
+## Running Examples
+1. `cd samples`
+2. `cargo run --bin 3d_camera_first_person`
 
-RUN apt-get update -y
-RUN apt-get install libasound2-dev mesa-common-dev libx11-dev libxrandr-dev libxi-dev xorg-dev libgl1-mesa-dev libglu1-mesa-dev -y
-```
-
-With the image defined, build it locally with:
-
-```sh
-docker build -t raylib_rs_env .
-```
-
-This will produce a local docker image called `raylib_rs_env` which `cross` will use instead of the default Linux image(s). To tell `cross` to use this image, create a `Cross.toml` file beside your `Cargo.toml`, and add the following (remembering to change things to suit your setup):
-
-```toml
-[target.x86_64-unknown-linux-gnu]
-image = "raylib_rs_env"
-```
-
-The Linux build can now be produced with:
-
-```sh
-cross build --target x86_64-unknown-linux-gnu --release
+# Extras
+- See [the wiki](https://github.com/raylib-rs/raylib-rs/wiki) for more info
+- Raylib has tons of features that are **not included by default**, such as support for various file formats like JPG, etc. We match raylibs default build configuration but this can be customized by enabling and disabling [feature flags](https://github.com/raylib-rs/raylib-rs/blob/unstable/raylib/Cargo.toml)
+- For a leaner custom build of raylib, set `default-features = false`, **but beware** that there are mandatory flags that when compiled without will break raylib(such as `SUPPORT_STANDARD_FILEIO`)
+- See how to integrate dearimgui into your project in [samples/imgui.rs](https://github.com/raylib-rs/raylib-rs/blob/unstable/samples/imgui.rs)
+
+# Contributing checklist:
+- [ ] Run `cargo test` and `cargo test --doc`  while in `raylib` safe bindings directory and make sure no tests fail
+- [ ] Test on major platforms (windows, linux)
+- [ ] Run examples: `cd samples` and `cargo run --bin <sample_name>`
+- [ ] Find & replace the version numbers in every Cargo.toml "5.6.x" -> "5.6.x"
+- [ ] Update the changelog
+- [ ] Keep a lookout on tagging functions with `#[inline]` , `#[must_use]` , and `const`
+
+### Updating raygui:
+The `raygui.h` file has to have this ifdef modified to point to where `raylib.h` is:
+```c
+#if !defined(RAYGUI_STANDALONE)
+#include "../raylib/src/raylib.h"
+#endif
 ```
 
-# MacOS / Darwin / IOS
-
-`cross` does not support cross-compilation to any of Apple's operating systems as of now. Keep an eye on their repository in case this ever changes.
+# Safe Binding characteristics
+- Resources are automatically cleaned up when they go out of scope (or when `std::mem::drop` is called). This is essentially RAII. This means that "Unload" functions are not exposed (and not necessary unless you obtain a `Weak` resource using make_weak()).
+- Most of the Raylib API is exposed through `RaylibHandle`, which is for enforcing that Raylib is only initialized once, and for making sure the window is closed properly. RaylibHandle has no size and goes away at compile time. Because of mutability rules, Raylib-rs is thread safe!
+- A `RaylibHandle` and `RaylibThread` are obtained through `raylib::init_window(...)` or through the newer `init()` function which will allow you to `build` up some window options before initialization (replaces `set_config_flags`). RaylibThread should not be sent to any other threads, or used in a any syncronization primitives (Mutex, Arc) etc.
+- Manually closing the window is unnecessary, because `CloseWindow` is automatically called when `RaylibHandle` goes out of scope.
+- `Model::set_material`, `Material::set_shader`, and `MaterialMap::set_texture` methods were added since one cannot set the fields directly. Also enforces correct ownership semantics.
+- `Font::from_data`, `Font::set_chars`, and `Font::set_texture` methods were added to create a `Font` from loaded `CharInfo` data.
+- `SubText` and `FormatText` are omitted, and are instead covered by Rust's string slicing and Rust's `format!` macro, respectively.
 
-# Extras
+# Tech Notes
 
-- In addition to the base library, there is also a convenient `ease` module which contains various interpolation/easing functions ported from raylib's `easings.h`, as well as a `Tween` struct to assist in using these functions.
-- Equivalent math and vector operations, ported from `raymath.h`, are `impl`ed on the various Vector and Matrix types. Operator overloading is used for more intuitive design.
+- Structs holding resources have RAII/move semantics, including: `Image`, `Texture2D`, `RenderTexture2D`, `Font`, `Mesh`, `Shader`, `Material`, and `Model`.
+- `Wave`, `Sound`, `Music`, and `AudioStream` have lifetimes bound to `AudioHandle`.
+- Functions dealing with string data take in `&str` and/or return an owned `String`, for the sake of safety. The exception to this is the gui draw functions which take &CStr to avoid per frame allocations. The `rstr!` macro helps make this easy.
+- In C, `LoadFontData` returns a pointer to a heap-allocated array of `CharInfo` structs. In this Rust binding, said array is copied into an owned `Vec<CharInfo>`, the original data is freed, and the owned Vec is returned.
+- In C, `LoadDroppedFiles` returns a pointer to an array of strings owned by raylib. Again, for safety and also ease of use, this binding copies said array into a `Vec<String>` which is returned to the caller.
+- I've tried to make linking automatic, though I've only tested on Windows 10, Ubuntu, and MacOS 15. Other platforms may have other considerations.
+- OpenGL 3.3, 2.1, and ES 2.0 may be forced via adding `["opengl_33"]`, `["opengl_21"]` or `["opengl_es_20]` to the `features` array in your Cargo.toml dependency definition.
 
 # Testing
 
 The raylib-test crate tests the bindings by opening a window, and checking the results of various functions. It requires nightly to use.
 
-# Future Goals
-
-- Port raylib examples over to Rust.
-- More tests.
-- More platform testing.
-- Even more testing.
-- Physac port?
-
 # Contribution & Support
 
 All contributions are welcome. Chat about raylib on [discord](https://discord.gg/VkzNHUE)