https://github.com/ten3roberts/ivy

A modular game engine framework written in Rust
https://github.com/ten3roberts/ivy

Last synced: 4 days ago
JSON representation

A modular game engine framework written in Rust

• Host: GitHub
• URL: https://github.com/ten3roberts/ivy
• Owner: ten3roberts
• License: apache-2.0
• Created: 2021-07-16T16:30:12.000Z (over 3 years ago)
• Default Branch: main
• Last Pushed: 2024-10-23T22:51:29.000Z (3 months ago)
• Last Synced: 2024-10-24T11:13:53.423Z (3 months ago)
• Language: Rust
• Size: 112 MB
• Stars: 32
• Watchers: 3
• Forks: 2
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# Ivy

## What it is

Ivy is a modular application and game framework for Rust.

This crate provides an amalgamation and rexport as well as aliasing for the

multiple `ivy` crates.

## [Guide](https://ten3roberts.github.io/ivy)

A user guide is provided to quickly familiarize the user with the basic usage of

the engine.

## Features

  - Vulkan high level rendering

  - PBR rendering and post processing

  - Rendergraph abstractions

  - Collision detection and realistic physics response

  - ECS driven architecture

  - Deferred dynamic events using observer pattern

  - Ray casting for arbitrary convex shapes

  - Handle based dynamic storage

  - Input system with composeable vector generation

  - UI system with configurable widget and positioning system

  - ... And more

# Gallery

![Cubes and Collision](./img/cubes.png)

## How it works

### Layers

The core of the program is an application. [`core::App`]. It defines the

update loop, and event handling.

From there, logic is extracted into layers which are run for each iteration.

Within a layer, the user is free to do whatever they want, from reading from

sockets, rendering using vulkan, or dispatching ECS workloads.

Due to the layered design, several high level concepts can work together and

not interfere, aswell as being inserted based on different configurations.

Layers can be thought of as plugin in high level containers of behaviour.

The existance of layer allow importing of behaviour from other crates without

concern of implementation details.

### Inter-layer communication

The application exposes different ways in which two layers can influence

each other.

- `world` contains the ECS world with all entities and components.

- `resources` is a typed storage accessed by handles. This is useful for

storing textures, models, or singletons that are to be shared between layers

and inside layers with dynamic borrow checking.

- `events` facilitates a broadcasting channel in which events can be sent

and listened to. Each layer can set up a receiver and iterate the sent events

of a specific type. This is best used for low frequency data to avoid busy

checking, like user input, state changes, or alike.

See the documentation for [`core::Layer`]