memkit-bevy 0.1.0-alpha.1

Bevy ECS integration for memkit
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

# memkit-bevy


**Bevy ECS integration for the memkit ecosystem.**

> **Version:** 0.1.0-alpha.1

[![Crates.io](https://img.shields.io/crates/v/memkit-bevy.svg)](https://crates.io/crates/memkit-bevy)
[![Documentation](https://docs.rs/memkit-bevy/badge.svg)](https://docs.rs/memkit-bevy)
[![License: MPL-2.0](https://img.shields.io/badge/License-MPL%202.0-brightgreen.svg)](https://opensource.org/licenses/MPL-2.0)

## Overview


memkit-bevy provides seamless integration between memkit and the Bevy game engine. It automatically manages frame lifecycle and exposes the allocator as a Bevy resource.

## Features


- **Automatic Frame Lifecycle** — Frame begin/end tied to Bevy's `First`/`Last` schedules
- **Resource Integration** — `MkAllocatorRes` as a Bevy `Resource`
- **System Sets** — `MkSystemSet::FrameBegin` and `MkSystemSet::FrameEnd` for ordering
- **Zero Configuration** — Just add the plugin and go
- **Optional Prelude** — Enable `bevy_prelude` feature for full Bevy re-exports

## Quick Start


```rust
use bevy::prelude::*;
use memkit_bevy::{MkPlugin, MkAllocatorRes};

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(MkPlugin::default())
        .add_systems(Update, my_system)
        .run();
}

fn my_system(alloc: Res<MkAllocatorRes>) {
    // Frame automatically managed by plugin
    // Allocations are valid until end of frame
    if let Some(data) = alloc.frame_box(MyData::new()) {
        // ... use data ...
    }
}

#[derive(Default)]

struct MyData {
    value: f32,
}
```

## Custom Configuration


```rust
use memkit::MkConfig;
use memkit_bevy::MkPlugin;

// Option 1: Custom config
let config = MkConfig {
    frame_arena_size: 32 * 1024 * 1024, // 32 MB
    ..Default::default()
};
App::new()
    .add_plugins(MkPlugin::with_config(config))
    .run();

// Option 2: Just set arena size
App::new()
    .add_plugins(MkPlugin::with_arena_size(64 * 1024 * 1024)) // 64 MB
    .run();
```

## System Ordering


memkit-bevy provides system sets for proper ordering:

```rust
use memkit_bevy::{MkPlugin, MkSystemSet};

App::new()
    .add_plugins(MkPlugin::default())
    // Run after frame begins
    .add_systems(First, my_init_system.after(MkSystemSet::FrameBegin))
    // Run before frame ends
    .add_systems(Last, my_cleanup_system.before(MkSystemSet::FrameEnd))
    .run();
```

## Allocation Methods


```rust
fn my_system(alloc: Res<MkAllocatorRes>) {
    // Raw pointer allocation (you must initialize)
    let ptr: *mut MyStruct = alloc.frame_alloc::<MyStruct>();
    
    // Boxed allocation (initialized)
    let boxed: Option<MkFrameBox<MyStruct>> = alloc.frame_box(MyStruct::default());
    
    // Slice allocation
    let slice: Option<MkFrameSlice<f32>> = alloc.frame_slice::<f32>(1024);
    
    // Check if frame is active
    if alloc.is_frame_active() {
        // Safe to allocate
    }
}
```

## Feature Flags


| Feature | Description |
|---------|-------------|
| `bevy_prelude` | Re-exports `bevy::prelude::*` for convenience |

## Types


| Type | Description |
|------|-------------|
| `MkPlugin` | Bevy plugin for memkit integration |
| `MkAllocatorRes` | Bevy resource wrapping `MkAllocator` |
| `MkSystemSet` | System sets for frame lifecycle ordering |

## Compatibility


| memkit-bevy | Bevy |
|-------------|------|
| 0.12.x | 0.17.x |

## How It Works


1. **Frame Begin** (`First` schedule): Calls `MkAllocator::begin_frame()`
2. **Your Systems** (`Update`, etc.): Use `Res<MkAllocatorRes>` for frame allocations
3. **Frame End** (`Last` schedule): Calls `MkAllocator::end_frame()`, resetting the arena

All frame allocations are automatically freed when the frame ends — no manual cleanup needed.

## License


This project is licensed under the Mozilla Public License 2.0 - see the [LICENSE.md](../LICENSE.md) file for details.