mirror of https://github.com/Leinnan/rpack.git
118 lines
3.6 KiB
Markdown
118 lines
3.6 KiB
Markdown
# Bevy_rPack
|
|
|
|
A Bevy plugin with support for the `rpack.json` atlases.
|
|
|
|
## Getting the rpack.json atlases
|
|
|
|
Generating a rpack atlas can be done in two ways:
|
|
- using `rpack_egui` application at [itch.io](https://mevlyshkin.itch.io/rpack). Just drop in files into program, specify settings and it should be possible to download both the json and image file for atlas.
|
|
- using `rpack_cli` CLI tool as described below.
|
|
|
|
### rpack_cli use guide
|
|
|
|
First install the tool:
|
|
|
|
```sh
|
|
cargo install rpack_cli
|
|
```
|
|
|
|
Guide assumptions:
|
|
- Commands are executed from the root of the Bevy project.
|
|
- Images used to generate the atlas are stored in subdirectories within the `tiles` directory of the Bevy project.
|
|
- Game assets are stored in the `assets` directory.
|
|
|
|
In order to generate a tilemap execute this command:
|
|
```sh
|
|
rpack_cli generate --source-paths "tiles/**/*" --size 1024 assets/game_tilemap
|
|
```
|
|
It is also possible to generate a config file for `rpack_cli` and then use it to generate a tilemaps:
|
|
```sh
|
|
rpack_cli config-create --source-paths "tiles/**/*" --size 1024 --output-path assets/tilemap tiles_config
|
|
rpack_cli tiles_config.rpack_gen.json
|
|
```
|
|
Both ways result in creation of two files:
|
|
- `assets/tilemap.png` containing atlas image
|
|
- `assets/tilemap.rpack.json` containing atlas image frames data used by bevy plugin.
|
|
|
|
Second way generated additional `tiles_config.rpack_gen.json` file that provides settings for the CLI tool.
|
|
|
|
With those files generated it should be possible to use atlases like in the example from `Example` docs section.
|
|
|
|
#### Bonus- generating tilemaps on build/runtime
|
|
|
|
Since `rpack_cli` is a rust library it can be called easily from Bevy application.
|
|
It can be useful for building special version of the game for artists in the team so they can run the game and be sure that they don't forget to rebuild atlases after doing changes in graphics.
|
|
|
|
In order to achieve that add this dependency to the project:
|
|
```toml
|
|
rpack_cli = "0.3"
|
|
```
|
|
Then in `main.rs` just before `App::new()` add something like this:
|
|
|
|
```rust
|
|
rpack_cli::TilemapGenerationConfig::read_from_file("example_config.rpack_gen.json")
|
|
.expect("Failed to read config")
|
|
.generate()
|
|
.expect("Failed to generate tilemap");
|
|
```
|
|
|
|
Then on each run of the game it will regenerate the atlas before running the game.
|
|
|
|
> Disclaimer: It should be used carefully and in most cases be called only in development builds on desktop platforms.
|
|
|
|
## Example
|
|
|
|
```rust
|
|
use bevy::prelude::*;
|
|
use bevy_rpack::prelude::*;
|
|
|
|
#[allow(dead_code)]
|
|
#[derive(Resource)]
|
|
struct Holder(pub Handle<RpackAtlasAsset>);
|
|
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins((DefaultPlugins, RpackAssetPlugin))
|
|
.add_systems(Startup, setup)
|
|
.add_systems(Update, atlas_loaded)
|
|
.run();
|
|
}
|
|
|
|
fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
|
|
commands.insert_resource(Holder(asset_server.load("tilemap.rpack.json")));
|
|
commands.spawn(Camera2d);
|
|
}
|
|
|
|
fn atlas_loaded(
|
|
mut ev_asset: EventReader<AssetEvent<RpackAtlasAsset>>,
|
|
atlases: RpackAtlases,
|
|
mut commands: Commands,
|
|
) {
|
|
if !ev_asset
|
|
.read()
|
|
.any(|ev| matches!(ev, AssetEvent::LoadedWithDependencies { id: _ }))
|
|
{
|
|
return;
|
|
}
|
|
if let Ok(sprite) = atlases.try_make_sprite("agents/spaceAstronauts_005") {
|
|
commands.spawn(sprite);
|
|
};
|
|
if let Ok(image_node) = atlases.try_make_image_node("agents/spaceShips_006") {
|
|
commands.spawn(image_node);
|
|
}
|
|
}
|
|
|
|
```
|
|
|
|
## Licence
|
|
|
|
`bevy_rpack` is dual-licensed under MIT and Apache 2.0 at your option.
|
|
|
|
## Bevy compatibility table
|
|
|
|
Bevy version | Crate version
|
|
--- | ---
|
|
0.17 | 0.3
|
|
0.16 | 0.2
|
|
0.15 | 0.1
|