stereokit-rust 0.4.0-alpha.22

High-Level Rust bindings around the StereoKitC library for XR
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
139
140
141
142
143
144
145
146
147
148

#include "rect_atlas.h"

///////////////////////////////////////////

rect_atlas_t rect_atlas_create(int32_t width, int32_t height) {
	rect_atlas_t result = {};
	result.free_space.add({0,0,width,height});
	result.w = width;
	result.h = height;
	return result;
}

///////////////////////////////////////////

void rect_atlas_destroy(rect_atlas_t *atlas) {
	atlas->free_space.free();
	atlas->packed    .free();
	*atlas = {};
}

///////////////////////////////////////////

int32_t _rect_atlas_fit(rect_area_t src, const rect_area_t &r) {
	if (r.w < src.w || r.h < src.h) return 0x7FFFFFFF;
	int16_t w_diff = (int16_t)(r.w - src.w);
	int16_t h_diff = (int16_t)(r.h - src.h);
	return w_diff << 16 | h_diff;
}

///////////////////////////////////////////

int32_t rect_atlas_add(rect_atlas_t *atlas, int32_t width, int32_t height) {
	int32_t idx = atlas->free_space.index_best_small_with({ 0,0,width,height }, _rect_atlas_fit);
	if (idx == -1 || atlas->free_space[idx].w < width || atlas->free_space[idx].h < height)
		return -1;

	const rect_area_t parent = atlas->free_space[idx];

	if (parent.h == height && parent.w == width) { 
		// Perfect fit!
		atlas->free_space.remove(idx);
	} else if (parent.h == height) {
		// Perfect vertical fit, just slide the bounds over to the right
		atlas->free_space[idx].x += width;
		atlas->free_space[idx].w -= width;
	} else if (parent.w == width) {
		// Perfect horizontal fit, just slide the bounds down
		atlas->free_space[idx].y += height;
		atlas->free_space[idx].h -= height;
	} else {
		// Split along the shortest edge, try and preserve large areas
		rect_area_t new_free = {};
		if (parent.h - height < parent.w - width) {
			// Vertical axis is shorter, split horizontally
			atlas->free_space[idx].y += height;
			atlas->free_space[idx].h -= height;
			atlas->free_space[idx].w  = width;
			new_free.x = parent.x + width;
			new_free.y = parent.y;
			new_free.w = parent.w - width;
			new_free.h = parent.h;
		} else {
			// Horizontal axis is shorter, split vertically
			atlas->free_space[idx].x += width;
			atlas->free_space[idx].w -= width;
			atlas->free_space[idx].h  = height;
			new_free.x = parent.x;
			new_free.y = parent.y + height;
			new_free.w = parent.w;
			new_free.h = parent.h - height;
		}
		atlas->free_space.add(new_free);
	}

	rect_area_t new_rect = {};
	new_rect.x = parent.x;
	new_rect.y = parent.y;
	new_rect.w = width;
	new_rect.h = height;
	atlas->used_area += width * height;
	return atlas->packed.add(new_rect);
}

///////////////////////////////////////////

int32_t _rect_atlas_add_free_space(rect_atlas_t *atlas, rect_area_t rect, int32_t idx) {
	int32_t rect_r = rect.x + rect.w;
	int32_t rect_b = rect.y + rect.h;
	int32_t result = -1;

	for (int32_t i = 0; i < atlas->free_space.count; i++) {
		if (i == idx) continue;
		rect_area_t cell = atlas->free_space[i];

		if (cell.h == rect.h && cell.y == rect.y) {
			int32_t cell_r = cell.x + cell.w;
			if (cell.x == rect_r) { // left side of this cell matches up
				atlas->free_space[i].x  = rect.x;
				atlas->free_space[i].w += rect.w;
				result = i;
				break;
			} else if (cell_r == rect.x) { // right side of this cell matches up
				atlas->free_space[i].w += rect.w;
				result = i;
				break;
			}
		} else if (cell.w == rect.w && cell.x == rect.x) {
			int32_t cell_b = cell.y + cell.h;
			if (cell.y == rect_b) { // top side of this cell matches up
				atlas->free_space[i].y  = rect.y;
				atlas->free_space[i].h += rect.h;
				result = i;
				break;
			} else if (cell_b == rect.y) { // bottom side of this cell matches up
				atlas->free_space[i].h += rect.h;
				result = i;
				break;
			}
		}
	}

	if (idx != -1 && result != -1) {
		// If this was already free space we knew about, but we merged it
		// with some existing stuff, then remove the old free space.
		atlas->free_space.remove(idx);
		if (result > idx)
			result -= 1;
	} else if (idx == -1 && result == -1) {
		// If the source was not free space, and we didn't find free space to
		// merge this into, make a new one!
		atlas->free_space.add(rect);
	}

	return result;
}

///////////////////////////////////////////

void rect_atlas_remove(rect_atlas_t *atlas, int32_t idx) {
	rect_area_t free_space = atlas->packed[idx];
	atlas->packed.remove(idx);
	atlas->used_area -= free_space.w * free_space.h;

	int32_t new_rect = _rect_atlas_add_free_space(atlas, free_space, -1);
	while (new_rect != -1) {
		new_rect = _rect_atlas_add_free_space(atlas, atlas->free_space[new_rect], new_rect);
	}
}