2023-03-25 - Rust - 1

Functions in Rust: A Real-World Example

Functions are an essential building block of any Rust program. In Rust, functions are defined using the fn keyword, followed by the function name and parameter list in parentheses. They can take input arguments and return output values. Functions can also be used as parameters to other functions, allowing us to write more expressive and reusable code.

In this blog post, we’ll explore a real-world example of using higher-order functions to sort objects in a game engine.

Defining the Object Struct

Consider a game engine that needs to render a scene on the screen. The engine has a function called render_object that takes an object and renders it on the screen. The function uses the object’s position, rotation, and other properties to calculate the position and orientation of the object on the screen.

To represent an object in the scene, we can define a struct called Object with a position and rotation property:

struct Object {
    position: Vector3,
    rotation: Quaternion,
}

Sorting Objects by Distance

To render a scene, the game engine needs to call the render_object function for each object in the scene. However, the order in which objects are rendered can affect the final image’s appearance, as objects in front should be rendered before objects behind them. Therefore, the game engine needs to sort the objects by their distance from the camera before rendering them.

To sort the objects, we can define a higher-order function called sort_objects_by_distance that takes a vector of objects and a function that calculates the distance of each object from the camera. The sort_objects_by_distance function then sorts the objects by their distance using the provided function and returns the sorted vector.

use ordered_float::OrderedFloat;

fn sort_objects_by_distance<F>(objects: &mut [Object], distance_fn: F) -> &mut [Object]
where
    F: Fn(&Object) -> f32,
{
    objects.sort_by_key(|object| OrderedFloat(distance_fn(object)));
    objects
}

In this example, we used the use keyword to import the OrderedFloat struct from the ordered-float crate. We then defined the sort_objects_by_distance function, which takes a mutable slice of objects and a function that calculates the distance of each object from the camera. The where keyword is used to specify the trait bound for the F type, which requires that F implements the Fn(&Object) -> f32 trait.

The sort_objects_by_distance function uses the sort_by_key method to sort the objects by their distance from the camera. The sort_by_key method takes a closure that returns the sort key for each element, which we calculate using the provided distance_fn function. We also used the OrderedFloat struct to ensure that the sorting is stable.

Rendering the Scene We can now use the sort_objects_by_distance function to sort the objects before rendering them:

fn render_scene(objects: &mut [Object]) {
    sort_objects_by_distance(objects, |object| object.position.distance(camera.position));
    for object in objects {
        render_object(object);
    }
}

In this example, we defined a render_scene function that takes a mutable slice of objects and sorts them by their distance from the camera using the sort_objects_by_distance function. We then iterate over the sorted objects and call the render_object function for each object.

Conclusion

Functions in Rust are an essential building block of any Rust program. They allow us to write code that performs a specific task and can be called from other parts of the program. Functions can take input arguments and return output values, making them versatile and powerful.

In this blog post, we explored a real-world example of using higher-order functions to sort objects in a game engine. We defined a sort_objects_by_distance function that takes a vector of objects and a function that calculates the distance of each object from the camera. We then used this function to sort the objects before rendering them, ensuring that objects in front were rendered before objects behind them.

Using higher-order functions like sort_objects_by_distance allows us to write more expressive and reusable code, making our game engine more maintainable and scalable.

I hope this blog post helped you understand how functions work in Rust and how they can be used to write efficient and elegant code.