aboutsummaryrefslogtreecommitdiff
path: root/src/core/transform.h
diff options
context:
space:
mode:
authorSebastiano Tronto <sebastiano@tronto.net>2024-10-04 12:15:37 +0200
committerSebastiano Tronto <sebastiano@tronto.net>2024-10-04 12:15:37 +0200
commit0de1530f4cea21f2bc0a0e0f1cbf9da016c7bda5 (patch)
treea0a64424190588e5f734c257dd312e1f89fcd1eb /src/core/transform.h
parent80b065f757240af7920862b3e09f32a6dc06d392 (diff)
downloadnissy-core-0de1530f4cea21f2bc0a0e0f1cbf9da016c7bda5.tar.gz
nissy-core-0de1530f4cea21f2bc0a0e0f1cbf9da016c7bda5.zip
Revert table-based transformations
Long live the giant switch!
Diffstat (limited to '')
-rw-r--r--src/core/transform.h463
1 files changed, 322 insertions, 141 deletions
diff --git a/src/core/transform.h b/src/core/transform.h
index f72e2af..83204d5 100644
--- a/src/core/transform.h
+++ b/src/core/transform.h
@@ -1,162 +1,343 @@
1#define TRANS_EDGES_ROTATION(T, c) \
2 compose_edges(compose_edges(TRANS_CUBE_ ## T, c), \
3 TRANS_CUBE_ ## T ## _INVERSE)
4#define TRANS_EDGES_MIRRORED(T, c) TRANS_EDGES_ROTATION(T, c)
5
6#define TRANS_CORNERS_ROTATION(T, c) \
7 compose_corners(compose_corners(TRANS_CUBE_ ## T, c), \
8 TRANS_CUBE_ ## T ## _INVERSE)
9#define TRANS_CORNERS_MIRRORED(T, c) \
10 invertco(compose_corners( \
11 compose_corners(TRANS_CUBE_ ## T, c), TRANS_CUBE_ ## T ## _INVERSE))
12
13#define TRANS_ROTATION(T, c) \
14 compose(compose(TRANS_CUBE_ ## T, c), \
15 TRANS_CUBE_ ## T ## _INVERSE)
16#define TRANS_MIRRORED(T, c) \
17 invertco(compose(compose(TRANS_CUBE_ ## T, c), \
18 TRANS_CUBE_ ## T ## _INVERSE))
19
1STATIC cube_t transform_edges(cube_t, uint8_t); 20STATIC cube_t transform_edges(cube_t, uint8_t);
2STATIC cube_t transform_corners(cube_t, uint8_t); 21STATIC cube_t transform_corners(cube_t, uint8_t);
3STATIC cube_t transform(cube_t, uint8_t); 22STATIC cube_t transform(cube_t, uint8_t);
4STATIC cube_t applytrans(cube_t, const char *); 23STATIC cube_t applytrans(cube_t, const char *);
5 24
6static uint8_t cube_trans_table[48][20] = {
7 [TRANS_UFr] = { TRANS_CUBE_UFr },
8 [TRANS_UFm] = { TRANS_CUBE_UFm },
9 [TRANS_ULr] = { TRANS_CUBE_ULr },
10 [TRANS_ULm] = { TRANS_CUBE_ULm },
11 [TRANS_UBr] = { TRANS_CUBE_UBr },
12 [TRANS_UBm] = { TRANS_CUBE_UBm },
13 [TRANS_URr] = { TRANS_CUBE_URr },
14 [TRANS_URm] = { TRANS_CUBE_URm },
15 [TRANS_DFr] = { TRANS_CUBE_DFr },
16 [TRANS_DFm] = { TRANS_CUBE_DFm },
17 [TRANS_DLr] = { TRANS_CUBE_DLr },
18 [TRANS_DLm] = { TRANS_CUBE_DLm },
19 [TRANS_DBr] = { TRANS_CUBE_DBr },
20 [TRANS_DBm] = { TRANS_CUBE_DBm },
21 [TRANS_DRr] = { TRANS_CUBE_DRr },
22 [TRANS_DRm] = { TRANS_CUBE_DRm },
23 [TRANS_RUr] = { TRANS_CUBE_RUr },
24 [TRANS_RUm] = { TRANS_CUBE_RUm },
25 [TRANS_RFr] = { TRANS_CUBE_RFr },
26 [TRANS_RFm] = { TRANS_CUBE_RFm },
27 [TRANS_RDr] = { TRANS_CUBE_RDr },
28 [TRANS_RDm] = { TRANS_CUBE_RDm },
29 [TRANS_RBr] = { TRANS_CUBE_RBr },
30 [TRANS_RBm] = { TRANS_CUBE_RBm },
31 [TRANS_LUr] = { TRANS_CUBE_LUr },
32 [TRANS_LUm] = { TRANS_CUBE_LUm },
33 [TRANS_LFr] = { TRANS_CUBE_LFr },
34 [TRANS_LFm] = { TRANS_CUBE_LFm },
35 [TRANS_LDr] = { TRANS_CUBE_LDr },
36 [TRANS_LDm] = { TRANS_CUBE_LDm },
37 [TRANS_LBr] = { TRANS_CUBE_LBr },
38 [TRANS_LBm] = { TRANS_CUBE_LBm },
39 [TRANS_FUr] = { TRANS_CUBE_FUr },
40 [TRANS_FUm] = { TRANS_CUBE_FUm },
41 [TRANS_FRr] = { TRANS_CUBE_FRr },
42 [TRANS_FRm] = { TRANS_CUBE_FRm },
43 [TRANS_FDr] = { TRANS_CUBE_FDr },
44 [TRANS_FDm] = { TRANS_CUBE_FDm },
45 [TRANS_FLr] = { TRANS_CUBE_FLr },
46 [TRANS_FLm] = { TRANS_CUBE_FLm },
47 [TRANS_BUr] = { TRANS_CUBE_BUr },
48 [TRANS_BUm] = { TRANS_CUBE_BUm },
49 [TRANS_BRr] = { TRANS_CUBE_BRr },
50 [TRANS_BRm] = { TRANS_CUBE_BRm },
51 [TRANS_BDr] = { TRANS_CUBE_BDr },
52 [TRANS_BDm] = { TRANS_CUBE_BDm },
53 [TRANS_BLr] = { TRANS_CUBE_BLr },
54 [TRANS_BLm] = { TRANS_CUBE_BLm },
55};
56
57static uint8_t cube_trans_table_inverse[48][20] = {
58 [TRANS_UFr] = { TRANS_CUBE_UFr_INVERSE },
59 [TRANS_UFm] = { TRANS_CUBE_UFm_INVERSE },
60 [TRANS_ULr] = { TRANS_CUBE_ULr_INVERSE },
61 [TRANS_ULm] = { TRANS_CUBE_ULm_INVERSE },
62 [TRANS_UBr] = { TRANS_CUBE_UBr_INVERSE },
63 [TRANS_UBm] = { TRANS_CUBE_UBm_INVERSE },
64 [TRANS_URr] = { TRANS_CUBE_URr_INVERSE },
65 [TRANS_URm] = { TRANS_CUBE_URm_INVERSE },
66 [TRANS_DFr] = { TRANS_CUBE_DFr_INVERSE },
67 [TRANS_DFm] = { TRANS_CUBE_DFm_INVERSE },
68 [TRANS_DLr] = { TRANS_CUBE_DLr_INVERSE },
69 [TRANS_DLm] = { TRANS_CUBE_DLm_INVERSE },
70 [TRANS_DBr] = { TRANS_CUBE_DBr_INVERSE },
71 [TRANS_DBm] = { TRANS_CUBE_DBm_INVERSE },
72 [TRANS_DRr] = { TRANS_CUBE_DRr_INVERSE },
73 [TRANS_DRm] = { TRANS_CUBE_DRm_INVERSE },
74 [TRANS_RUr] = { TRANS_CUBE_RUr_INVERSE },
75 [TRANS_RUm] = { TRANS_CUBE_RUm_INVERSE },
76 [TRANS_RFr] = { TRANS_CUBE_RFr_INVERSE },
77 [TRANS_RFm] = { TRANS_CUBE_RFm_INVERSE },
78 [TRANS_RDr] = { TRANS_CUBE_RDr_INVERSE },
79 [TRANS_RDm] = { TRANS_CUBE_RDm_INVERSE },
80 [TRANS_RBr] = { TRANS_CUBE_RBr_INVERSE },
81 [TRANS_RBm] = { TRANS_CUBE_RBm_INVERSE },
82 [TRANS_LUr] = { TRANS_CUBE_LUr_INVERSE },
83 [TRANS_LUm] = { TRANS_CUBE_LUm_INVERSE },
84 [TRANS_LFr] = { TRANS_CUBE_LFr_INVERSE },
85 [TRANS_LFm] = { TRANS_CUBE_LFm_INVERSE },
86 [TRANS_LDr] = { TRANS_CUBE_LDr_INVERSE },
87 [TRANS_LDm] = { TRANS_CUBE_LDm_INVERSE },
88 [TRANS_LBr] = { TRANS_CUBE_LBr_INVERSE },
89 [TRANS_LBm] = { TRANS_CUBE_LBm_INVERSE },
90 [TRANS_FUr] = { TRANS_CUBE_FUr_INVERSE },
91 [TRANS_FUm] = { TRANS_CUBE_FUm_INVERSE },
92 [TRANS_FRr] = { TRANS_CUBE_FRr_INVERSE },
93 [TRANS_FRm] = { TRANS_CUBE_FRm_INVERSE },
94 [TRANS_FDr] = { TRANS_CUBE_FDr_INVERSE },
95 [TRANS_FDm] = { TRANS_CUBE_FDm_INVERSE },
96 [TRANS_FLr] = { TRANS_CUBE_FLr_INVERSE },
97 [TRANS_FLm] = { TRANS_CUBE_FLm_INVERSE },
98 [TRANS_BUr] = { TRANS_CUBE_BUr_INVERSE },
99 [TRANS_BUm] = { TRANS_CUBE_BUm_INVERSE },
100 [TRANS_BRr] = { TRANS_CUBE_BRr_INVERSE },
101 [TRANS_BRm] = { TRANS_CUBE_BRm_INVERSE },
102 [TRANS_BDr] = { TRANS_CUBE_BDr_INVERSE },
103 [TRANS_BDm] = { TRANS_CUBE_BDm_INVERSE },
104 [TRANS_BLr] = { TRANS_CUBE_BLr_INVERSE },
105 [TRANS_BLm] = { TRANS_CUBE_BLm_INVERSE },
106};
107
108STATIC cube_t 25STATIC cube_t
109transform_edges(cube_t c, uint8_t t) 26transform_edges(cube_t c, uint8_t t)
110{ 27{
111 cube_t ret, trans_cube, trans_inv; 28 switch (t) {
112 29 case TRANS_UFr:
113 DBG_ASSERT(t < 48, ZERO_CUBE, 30 return c;
114 "transform: invalid transformation %" PRIu8 31 case TRANS_ULr:
115 ", must be between 0 and 47\n", t); 32 return TRANS_EDGES_ROTATION(ULr, c);
116 33 case TRANS_UBr:
117 trans_cube = cubefromarray_single(cube_trans_table[t]); 34 return TRANS_EDGES_ROTATION(UBr, c);
118 trans_inv = cubefromarray_single(cube_trans_table_inverse[t]); 35 case TRANS_URr:
119 36 return TRANS_EDGES_ROTATION(URr, c);
120 ret = compose_edges(trans_cube, c); 37 case TRANS_DFr:
121 ret = compose_edges(ret, trans_inv); 38 return TRANS_EDGES_ROTATION(DFr, c);
122 39 case TRANS_DLr:
123 return ret; 40 return TRANS_EDGES_ROTATION(DLr, c);
41 case TRANS_DBr:
42 return TRANS_EDGES_ROTATION(DBr, c);
43 case TRANS_DRr:
44 return TRANS_EDGES_ROTATION(DRr, c);
45 case TRANS_RUr:
46 return TRANS_EDGES_ROTATION(RUr, c);
47 case TRANS_RFr:
48 return TRANS_EDGES_ROTATION(RFr, c);
49 case TRANS_RDr:
50 return TRANS_EDGES_ROTATION(RDr, c);
51 case TRANS_RBr:
52 return TRANS_EDGES_ROTATION(RBr, c);
53 case TRANS_LUr:
54 return TRANS_EDGES_ROTATION(LUr, c);
55 case TRANS_LFr:
56 return TRANS_EDGES_ROTATION(LFr, c);
57 case TRANS_LDr:
58 return TRANS_EDGES_ROTATION(LDr, c);
59 case TRANS_LBr:
60 return TRANS_EDGES_ROTATION(LBr, c);
61 case TRANS_FUr:
62 return TRANS_EDGES_ROTATION(FUr, c);
63 case TRANS_FRr:
64 return TRANS_EDGES_ROTATION(FRr, c);
65 case TRANS_FDr:
66 return TRANS_EDGES_ROTATION(FDr, c);
67 case TRANS_FLr:
68 return TRANS_EDGES_ROTATION(FLr, c);
69 case TRANS_BUr:
70 return TRANS_EDGES_ROTATION(BUr, c);
71 case TRANS_BRr:
72 return TRANS_EDGES_ROTATION(BRr, c);
73 case TRANS_BDr:
74 return TRANS_EDGES_ROTATION(BDr, c);
75 case TRANS_BLr:
76 return TRANS_EDGES_ROTATION(BLr, c);
77 case TRANS_UFm:
78 return TRANS_EDGES_MIRRORED(UFm, c);
79 case TRANS_ULm:
80 return TRANS_EDGES_MIRRORED(ULm, c);
81 case TRANS_UBm:
82 return TRANS_EDGES_MIRRORED(UBm, c);
83 case TRANS_URm:
84 return TRANS_EDGES_MIRRORED(URm, c);
85 case TRANS_DFm:
86 return TRANS_EDGES_MIRRORED(DFm, c);
87 case TRANS_DLm:
88 return TRANS_EDGES_MIRRORED(DLm, c);
89 case TRANS_DBm:
90 return TRANS_EDGES_MIRRORED(DBm, c);
91 case TRANS_DRm:
92 return TRANS_EDGES_MIRRORED(DRm, c);
93 case TRANS_RUm:
94 return TRANS_EDGES_MIRRORED(RUm, c);
95 case TRANS_RFm:
96 return TRANS_EDGES_MIRRORED(RFm, c);
97 case TRANS_RDm:
98 return TRANS_EDGES_MIRRORED(RDm, c);
99 case TRANS_RBm:
100 return TRANS_EDGES_MIRRORED(RBm, c);
101 case TRANS_LUm:
102 return TRANS_EDGES_MIRRORED(LUm, c);
103 case TRANS_LFm:
104 return TRANS_EDGES_MIRRORED(LFm, c);
105 case TRANS_LDm:
106 return TRANS_EDGES_MIRRORED(LDm, c);
107 case TRANS_LBm:
108 return TRANS_EDGES_MIRRORED(LBm, c);
109 case TRANS_FUm:
110 return TRANS_EDGES_MIRRORED(FUm, c);
111 case TRANS_FRm:
112 return TRANS_EDGES_MIRRORED(FRm, c);
113 case TRANS_FDm:
114 return TRANS_EDGES_MIRRORED(FDm, c);
115 case TRANS_FLm:
116 return TRANS_EDGES_MIRRORED(FLm, c);
117 case TRANS_BUm:
118 return TRANS_EDGES_MIRRORED(BUm, c);
119 case TRANS_BRm:
120 return TRANS_EDGES_MIRRORED(BRm, c);
121 case TRANS_BDm:
122 return TRANS_EDGES_MIRRORED(BDm, c);
123 case TRANS_BLm:
124 return TRANS_EDGES_MIRRORED(BLm, c);
125 default:
126 LOG("transform error, unknown transformation %" PRIu8 "\n", t);
127 return ZERO_CUBE;
128 }
124} 129}
125 130
126STATIC cube_t 131STATIC cube_t
127transform_corners(cube_t c, uint8_t t) 132transform_corners(cube_t c, uint8_t t)
128{ 133{
129 cube_t ret, trans_cube, trans_inv; 134 switch (t) {
130 135 case TRANS_UFr:
131 DBG_ASSERT(t < 48, ZERO_CUBE, 136 return c;
132 "transform: invalid transformation %" PRIu8 137 case TRANS_ULr:
133 ", must be between 0 and 47\n", t); 138 return TRANS_CORNERS_ROTATION(ULr, c);
134 139 case TRANS_UBr:
135 trans_cube = cubefromarray_single(cube_trans_table[t]); 140 return TRANS_CORNERS_ROTATION(UBr, c);
136 trans_inv = cubefromarray_single(cube_trans_table_inverse[t]); 141 case TRANS_URr:
137 142 return TRANS_CORNERS_ROTATION(URr, c);
138 ret = compose_corners(trans_cube, c); 143 case TRANS_DFr:
139 ret = compose_corners(ret, trans_inv); 144 return TRANS_CORNERS_ROTATION(DFr, c);
140 145 case TRANS_DLr:
141 return t < 24 ? ret : invertco(ret); 146 return TRANS_CORNERS_ROTATION(DLr, c);
147 case TRANS_DBr:
148 return TRANS_CORNERS_ROTATION(DBr, c);
149 case TRANS_DRr:
150 return TRANS_CORNERS_ROTATION(DRr, c);
151 case TRANS_RUr:
152 return TRANS_CORNERS_ROTATION(RUr, c);
153 case TRANS_RFr:
154 return TRANS_CORNERS_ROTATION(RFr, c);
155 case TRANS_RDr:
156 return TRANS_CORNERS_ROTATION(RDr, c);
157 case TRANS_RBr:
158 return TRANS_CORNERS_ROTATION(RBr, c);
159 case TRANS_LUr:
160 return TRANS_CORNERS_ROTATION(LUr, c);
161 case TRANS_LFr:
162 return TRANS_CORNERS_ROTATION(LFr, c);
163 case TRANS_LDr:
164 return TRANS_CORNERS_ROTATION(LDr, c);
165 case TRANS_LBr:
166 return TRANS_CORNERS_ROTATION(LBr, c);
167 case TRANS_FUr:
168 return TRANS_CORNERS_ROTATION(FUr, c);
169 case TRANS_FRr:
170 return TRANS_CORNERS_ROTATION(FRr, c);
171 case TRANS_FDr:
172 return TRANS_CORNERS_ROTATION(FDr, c);
173 case TRANS_FLr:
174 return TRANS_CORNERS_ROTATION(FLr, c);
175 case TRANS_BUr:
176 return TRANS_CORNERS_ROTATION(BUr, c);
177 case TRANS_BRr:
178 return TRANS_CORNERS_ROTATION(BRr, c);
179 case TRANS_BDr:
180 return TRANS_CORNERS_ROTATION(BDr, c);
181 case TRANS_BLr:
182 return TRANS_CORNERS_ROTATION(BLr, c);
183 case TRANS_UFm:
184 return TRANS_CORNERS_MIRRORED(UFm, c);
185 case TRANS_ULm:
186 return TRANS_CORNERS_MIRRORED(ULm, c);
187 case TRANS_UBm:
188 return TRANS_CORNERS_MIRRORED(UBm, c);
189 case TRANS_URm:
190 return TRANS_CORNERS_MIRRORED(URm, c);
191 case TRANS_DFm:
192 return TRANS_CORNERS_MIRRORED(DFm, c);
193 case TRANS_DLm:
194 return TRANS_CORNERS_MIRRORED(DLm, c);
195 case TRANS_DBm:
196 return TRANS_CORNERS_MIRRORED(DBm, c);
197 case TRANS_DRm:
198 return TRANS_CORNERS_MIRRORED(DRm, c);
199 case TRANS_RUm:
200 return TRANS_CORNERS_MIRRORED(RUm, c);
201 case TRANS_RFm:
202 return TRANS_CORNERS_MIRRORED(RFm, c);
203 case TRANS_RDm:
204 return TRANS_CORNERS_MIRRORED(RDm, c);
205 case TRANS_RBm:
206 return TRANS_CORNERS_MIRRORED(RBm, c);
207 case TRANS_LUm:
208 return TRANS_CORNERS_MIRRORED(LUm, c);
209 case TRANS_LFm:
210 return TRANS_CORNERS_MIRRORED(LFm, c);
211 case TRANS_LDm:
212 return TRANS_CORNERS_MIRRORED(LDm, c);
213 case TRANS_LBm:
214 return TRANS_CORNERS_MIRRORED(LBm, c);
215 case TRANS_FUm:
216 return TRANS_CORNERS_MIRRORED(FUm, c);
217 case TRANS_FRm:
218 return TRANS_CORNERS_MIRRORED(FRm, c);
219 case TRANS_FDm:
220 return TRANS_CORNERS_MIRRORED(FDm, c);
221 case TRANS_FLm:
222 return TRANS_CORNERS_MIRRORED(FLm, c);
223 case TRANS_BUm:
224 return TRANS_CORNERS_MIRRORED(BUm, c);
225 case TRANS_BRm:
226 return TRANS_CORNERS_MIRRORED(BRm, c);
227 case TRANS_BDm:
228 return TRANS_CORNERS_MIRRORED(BDm, c);
229 case TRANS_BLm:
230 return TRANS_CORNERS_MIRRORED(BLm, c);
231 default:
232 LOG("transform error, unknown transformation %" PRIu8 "\n", t);
233 return ZERO_CUBE;
234 }
142} 235}
143 236
144STATIC cube_t 237STATIC cube_t
145transform(cube_t c, uint8_t t) 238transform(cube_t c, uint8_t t)
146{ 239{
147 cube_t ret, trans_cube, trans_inv; 240 switch (t) {
148 241 case TRANS_UFr:
149 DBG_ASSERT(t < 48, ZERO_CUBE, 242 return c;
150 "transform: invalid transformation %" PRIu8 243 case TRANS_ULr:
151 ", must be between 0 and 47\n", t); 244 return TRANS_ROTATION(ULr, c);
152 245 case TRANS_UBr:
153 trans_cube = cubefromarray_single(cube_trans_table[t]); 246 return TRANS_ROTATION(UBr, c);
154 trans_inv = cubefromarray_single(cube_trans_table_inverse[t]); 247 case TRANS_URr:
155 248 return TRANS_ROTATION(URr, c);
156 ret = compose(trans_cube, c); 249 case TRANS_DFr:
157 ret = compose(ret, trans_inv); 250 return TRANS_ROTATION(DFr, c);
158 251 case TRANS_DLr:
159 return t < 24 ? ret : invertco(ret); 252 return TRANS_ROTATION(DLr, c);
253 case TRANS_DBr:
254 return TRANS_ROTATION(DBr, c);
255 case TRANS_DRr:
256 return TRANS_ROTATION(DRr, c);
257 case TRANS_RUr:
258 return TRANS_ROTATION(RUr, c);
259 case TRANS_RFr:
260 return TRANS_ROTATION(RFr, c);
261 case TRANS_RDr:
262 return TRANS_ROTATION(RDr, c);
263 case TRANS_RBr:
264 return TRANS_ROTATION(RBr, c);
265 case TRANS_LUr:
266 return TRANS_ROTATION(LUr, c);
267 case TRANS_LFr:
268 return TRANS_ROTATION(LFr, c);
269 case TRANS_LDr:
270 return TRANS_ROTATION(LDr, c);
271 case TRANS_LBr:
272 return TRANS_ROTATION(LBr, c);
273 case TRANS_FUr:
274 return TRANS_ROTATION(FUr, c);
275 case TRANS_FRr:
276 return TRANS_ROTATION(FRr, c);
277 case TRANS_FDr:
278 return TRANS_ROTATION(FDr, c);
279 case TRANS_FLr:
280 return TRANS_ROTATION(FLr, c);
281 case TRANS_BUr:
282 return TRANS_ROTATION(BUr, c);
283 case TRANS_BRr:
284 return TRANS_ROTATION(BRr, c);
285 case TRANS_BDr:
286 return TRANS_ROTATION(BDr, c);
287 case TRANS_BLr:
288 return TRANS_ROTATION(BLr, c);
289 case TRANS_UFm:
290 return TRANS_MIRRORED(UFm, c);
291 case TRANS_ULm:
292 return TRANS_MIRRORED(ULm, c);
293 case TRANS_UBm:
294 return TRANS_MIRRORED(UBm, c);
295 case TRANS_URm:
296 return TRANS_MIRRORED(URm, c);
297 case TRANS_DFm:
298 return TRANS_MIRRORED(DFm, c);
299 case TRANS_DLm:
300 return TRANS_MIRRORED(DLm, c);
301 case TRANS_DBm:
302 return TRANS_MIRRORED(DBm, c);
303 case TRANS_DRm:
304 return TRANS_MIRRORED(DRm, c);
305 case TRANS_RUm:
306 return TRANS_MIRRORED(RUm, c);
307 case TRANS_RFm:
308 return TRANS_MIRRORED(RFm, c);
309 case TRANS_RDm:
310 return TRANS_MIRRORED(RDm, c);
311 case TRANS_RBm:
312 return TRANS_MIRRORED(RBm, c);
313 case TRANS_LUm:
314 return TRANS_MIRRORED(LUm, c);
315 case TRANS_LFm:
316 return TRANS_MIRRORED(LFm, c);
317 case TRANS_LDm:
318 return TRANS_MIRRORED(LDm, c);
319 case TRANS_LBm:
320 return TRANS_MIRRORED(LBm, c);
321 case TRANS_FUm:
322 return TRANS_MIRRORED(FUm, c);
323 case TRANS_FRm:
324 return TRANS_MIRRORED(FRm, c);
325 case TRANS_FDm:
326 return TRANS_MIRRORED(FDm, c);
327 case TRANS_FLm:
328 return TRANS_MIRRORED(FLm, c);
329 case TRANS_BUm:
330 return TRANS_MIRRORED(BUm, c);
331 case TRANS_BRm:
332 return TRANS_MIRRORED(BRm, c);
333 case TRANS_BDm:
334 return TRANS_MIRRORED(BDm, c);
335 case TRANS_BLm:
336 return TRANS_MIRRORED(BLm, c);
337 default:
338 LOG("transform error, unknown transformation %" PRIu8 "\n", t);
339 return ZERO_CUBE;
340 }
160} 341}
161 342
162STATIC cube_t 343STATIC cube_t

Generated with cgit - Back to sebastiano.tronto.net