cotis-raylib 0.1.0-alpha

Raylib-backed renderer for Cotis
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

# cotis-raylib

`cotis-raylib` is the raylib-backed desktop renderer for [Cotis](https://docs.rs/cotis). It implements Cotis's `CotisRenderer` and `CotisRendererAsync` traits on top of [raylib](https://crates.io/crates/raylib) 6.x.

> **Status:** Early `0.1.0-alpha` release. APIs are still evolving alongside the core Cotis crates.

This repository contains the **renderer backend** only. It does not define layout or UI element configuration by itself. For a runnable desktop app, combine it with core Cotis crates, a layout engine, and a pipe from the [ecosystem](#ecosystem) below.

## Architecture

Each frame flows through five stages. This crate owns the renderer stage:

```mermaid
flowchart LR
    UI[UI_closure] --> LayoutMgr[CotisLayoutManager]
    LayoutMgr --> LayoutOut[RenderCommandOutput]
    LayoutOut --> Pipe[cotis-pipes]
    Pipe --> Renderer[RaylibRender]
```

1. A layout manager prepares for the frame.
2. UI code builds the element tree through the configurator API.
3. The layout manager produces layout output items.
4. A pipe transforms those items into renderer commands.
5. `RaylibRender` draws the command stream through raylib.

## Installation

Add the renderer and required core crates to your `Cargo.toml`:

```toml
cotis-raylib = "0.1.0-alpha"
cotis = "0.1.0-alpha"
cotis-defaults = "0.1.0-alpha"
cotis-utils = "0.1.0-alpha"
cotis-layout = "0.1.0-alpha"
cotis-pipes = "0.1.0-alpha"
```

The [raylib](https://crates.io/crates/raylib) crate links against native raylib libraries. On Linux you may need development packages for X11, OpenGL, and audio (for example `libx11-dev`, `libxrandr-dev`, `libxi-dev`, `libgl1-mesa-dev`, `libasound2-dev`).

## Quick start

Clone this repository and run the basic example from the repository root:

```bash
git clone https://github.com/igna-778/cotis-raylib
cd cotis-raylib
cargo run -p cotis-raylib --example basic_example
```

That example opens a resizable window, lays out UI with `cotis-layout` and `cotis-pipes`, and renders through raylib.

### Typical app wiring

```rust
use cotis::cotis_app::CotisApp;
use cotis_layout::preamble::CotisLayoutManager;
use cotis_pipes::cotis_layout_pipes::CotisLayoutToRenderListPipeForGenerics;
use cotis_raylib::prelude::RaylibRender;
use cotis_utils::math::Dimensions;

let renderer = RaylibRender::auto_start();
let manager = CotisLayoutManager::new(Dimensions::new(1000.0, 800.0));
let mut app = CotisApp::new(renderer, manager, CotisLayoutToRenderListPipeForGenerics);

while !app.render().window_should_close() {
    app.compute_frame(|root| {
        // Build your UI tree here.
    });
}
```

Swap `cotis-raylib` for [`cotis-wgpu`](https://github.com/igna-778/cotis-wgpu) or another backend without changing layout or UI code.

### Local examples

This repository ships runnable examples under `cotis-raylib/examples/`:

| Example | Command |
|---------|---------|
| `basic_example` | `cargo run -p cotis-raylib --example basic_example` |
| `circle_example` | `cargo run -p cotis-raylib --example circle_example` |
| `gradients_example` | `cargo run -p cotis-raylib --example gradients_example --features complex-color` |
| `gradients_example_solid` | `cargo run -p cotis-raylib --example gradients_example_solid` |

Examples load assets from `./examples/` relative to the working directory (run from the repository root). The bundled Roboto font is licensed under the [Apache License 2.0](https://fonts.google.com/specimen/Roboto) (Google Fonts).

## Ecosystem

Cotis is split across several repositories. This repo provides the raylib renderer; sibling repos provide core traits, layout, and pipes.

| Repository | Role |
|------------|------|
| [`cotis`](https://github.com/igna-778/cotis) | Core traits and `CotisApp` orchestration |
| [`cotis-layout`](https://github.com/igna-778/cotis-layout) | Flexbox-style layout engine (`CotisLayoutManager`) |
| [`cotis-pipes`](https://github.com/igna-778/cotis-pipes) | Layout output to render commands (`CotisLayoutToRenderListPipeForGenerics`) |
| [`cotis-wgpu`](https://github.com/igna-778/cotis-wgpu) | Desktop renderer (wgpu + winit + glyphon) |
| [**cotis-raylib**](https://github.com/igna-778/cotis-raylib) (this repo) | Desktop renderer (raylib) |
| [`cotis-renderer-template`](https://github.com/igna-778/cotis-renderer-template) | Scaffold for authoring a custom render backend |
| [`cotis-cli`](https://github.com/igna-778/cotis-cli) | Plugin host for installable build and run routines |

Pick a renderer backend and swap it without changing layout or UI code. Use `cotis-renderer-template` to implement a new backend.

## Features

| Feature | Effect |
|---------|--------|
| `test-render` | Exposes the `test_render` module (`RayTestRender`) for scaled/headless-style testing |
| `complex-color` | Enables gradient and layered fills (requires `cotis-defaults/complex_color`) |

## Documentation

- API reference: `cargo doc -p cotis-raylib --open`
- Published docs: [cotis-raylib](https://docs.rs/cotis-raylib)
- Core crate docs: [cotis](https://docs.rs/cotis), [cotis-defaults](https://docs.rs/cotis-defaults), [cotis-utils](https://docs.rs/cotis-utils)