From c5c5017a335208881e27fc8f72c1d0145a04622a Mon Sep 17 00:00:00 2001 From: Sebastiano Tronto Date: Sun, 9 Jun 2024 12:43:49 +0200 Subject: Remvoed cube_fast_t and more. More cleaning up to do. --- src/cube_transform.h | 470 +++++++++++++++++---------------------------------- 1 file changed, 155 insertions(+), 315 deletions(-) (limited to 'src/cube_transform.h') diff --git a/src/cube_transform.h b/src/cube_transform.h index d9a0941..358b051 100644 --- a/src/cube_transform.h +++ b/src/cube_transform.h @@ -1,336 +1,176 @@ +/* TODO: remove these macros, if the below works */ + #define _trans_edges_rotation(T, c) \ - compose_fast_edges(compose_fast_edges(_trans_cube_ ## T, c), \ + compose_edges(compose_edges(_trans_cube_ ## T, c), \ _trans_cube_ ## T ## _inverse) #define _trans_edges_mirrored(T, c) _trans_edges_rotation(T, c) #define _trans_corners_rotation(T, c) \ - compose_fast_corners(compose_fast_corners(_trans_cube_ ## T, c), \ + compose_corners(compose_corners(_trans_cube_ ## T, c), \ _trans_cube_ ## T ## _inverse) #define _trans_corners_mirrored(T, c) \ - invertco_fast(compose_fast_corners( \ - compose_fast_corners(_trans_cube_ ## T, c), _trans_cube_ ## T ## _inverse)) + invertco(compose_corners( \ + compose_corners(_trans_cube_ ## T, c), _trans_cube_ ## T ## _inverse)) #define _trans_rotation(T, c) \ - compose_fast(compose_fast(_trans_cube_ ## T, c), \ + compose(compose(_trans_cube_ ## T, c), \ _trans_cube_ ## T ## _inverse) #define _trans_mirrored(T, c) \ - invertco_fast(compose_fast(compose_fast(_trans_cube_ ## T, c), \ + invertco(compose(compose(_trans_cube_ ## T, c), \ _trans_cube_ ## T ## _inverse)) -_static cube_fast_t -transform_edges(cube_fast_t c, uint8_t t) +static cube_t cube_trans_table[48] = { + [_trans_UFr] = _trans_cube_UFr, + [_trans_UFm] = _trans_cube_UFm, + [_trans_ULr] = _trans_cube_URr, + [_trans_ULm] = _trans_cube_ULm, + [_trans_UBr] = _trans_cube_UBr, + [_trans_UBm] = _trans_cube_UBm, + [_trans_URr] = _trans_cube_ULr, + [_trans_URm] = _trans_cube_URm, + [_trans_DFr] = _trans_cube_DFr, + [_trans_DFm] = _trans_cube_DFm, + [_trans_DLr] = _trans_cube_DLr, + [_trans_DLm] = _trans_cube_DRm, + [_trans_DBr] = _trans_cube_DBr, + [_trans_DBm] = _trans_cube_DBm, + [_trans_DRr] = _trans_cube_DRr, + [_trans_DRm] = _trans_cube_DLm, + [_trans_RUr] = _trans_cube_FRr, + [_trans_RUm] = _trans_cube_FLm, + [_trans_RFr] = _trans_cube_LFr, + [_trans_RFm] = _trans_cube_RFm, + [_trans_RDr] = _trans_cube_BLr, + [_trans_RDm] = _trans_cube_BRm, + [_trans_RBr] = _trans_cube_RBr, + [_trans_RBm] = _trans_cube_LBm, + [_trans_LUr] = _trans_cube_FLr, + [_trans_LUm] = _trans_cube_FRm, + [_trans_LFr] = _trans_cube_RFr, + [_trans_LFm] = _trans_cube_LFm, + [_trans_LDr] = _trans_cube_BRr, + [_trans_LDm] = _trans_cube_BLm, + [_trans_LBr] = _trans_cube_LBr, + [_trans_LBm] = _trans_cube_RBm, + [_trans_FUr] = _trans_cube_FUr, + [_trans_FUm] = _trans_cube_FUm, + [_trans_FRr] = _trans_cube_RUr, + [_trans_FRm] = _trans_cube_LUm, + [_trans_FDr] = _trans_cube_BUr, + [_trans_FDm] = _trans_cube_BUm, + [_trans_FLr] = _trans_cube_LUr, + [_trans_FLm] = _trans_cube_RUm, + [_trans_BUr] = _trans_cube_FDr, + [_trans_BUm] = _trans_cube_FDm, + [_trans_BRr] = _trans_cube_LDr, + [_trans_BRm] = _trans_cube_RDm, + [_trans_BDr] = _trans_cube_BDr, + [_trans_BDm] = _trans_cube_BDm, + [_trans_BLr] = _trans_cube_RDr, + [_trans_BLm] = _trans_cube_LDm, +}; + +static cube_t cube_trans_table_inverse[48] = { + [_trans_UFr] = _trans_cube_UFr_inverse, + [_trans_UFm] = _trans_cube_UFm_inverse, + [_trans_ULr] = _trans_cube_URr_inverse, + [_trans_ULm] = _trans_cube_ULm_inverse, + [_trans_UBr] = _trans_cube_UBr_inverse, + [_trans_UBm] = _trans_cube_UBm_inverse, + [_trans_URr] = _trans_cube_ULr_inverse, + [_trans_URm] = _trans_cube_URm_inverse, + [_trans_DFr] = _trans_cube_DFr_inverse, + [_trans_DFm] = _trans_cube_DFm_inverse, + [_trans_DLr] = _trans_cube_DLr_inverse, + [_trans_DLm] = _trans_cube_DRm_inverse, + [_trans_DBr] = _trans_cube_DBr_inverse, + [_trans_DBm] = _trans_cube_DBm_inverse, + [_trans_DRr] = _trans_cube_DRr_inverse, + [_trans_DRm] = _trans_cube_DLm_inverse, + [_trans_RUr] = _trans_cube_FRr_inverse, + [_trans_RUm] = _trans_cube_FLm_inverse, + [_trans_RFr] = _trans_cube_LFr_inverse, + [_trans_RFm] = _trans_cube_RFm_inverse, + [_trans_RDr] = _trans_cube_BLr_inverse, + [_trans_RDm] = _trans_cube_BRm_inverse, + [_trans_RBr] = _trans_cube_RBr_inverse, + [_trans_RBm] = _trans_cube_LBm_inverse, + [_trans_LUr] = _trans_cube_FLr_inverse, + [_trans_LUm] = _trans_cube_FRm_inverse, + [_trans_LFr] = _trans_cube_RFr_inverse, + [_trans_LFm] = _trans_cube_LFm_inverse, + [_trans_LDr] = _trans_cube_BRr_inverse, + [_trans_LDm] = _trans_cube_BLm_inverse, + [_trans_LBr] = _trans_cube_LBr_inverse, + [_trans_LBm] = _trans_cube_RBm_inverse, + [_trans_FUr] = _trans_cube_FUr_inverse, + [_trans_FUm] = _trans_cube_FUm_inverse, + [_trans_FRr] = _trans_cube_RUr_inverse, + [_trans_FRm] = _trans_cube_LUm_inverse, + [_trans_FDr] = _trans_cube_BUr_inverse, + [_trans_FDm] = _trans_cube_BUm_inverse, + [_trans_FLr] = _trans_cube_LUr_inverse, + [_trans_FLm] = _trans_cube_RUm_inverse, + [_trans_BUr] = _trans_cube_FDr_inverse, + [_trans_BUm] = _trans_cube_FDm_inverse, + [_trans_BRr] = _trans_cube_LDr_inverse, + [_trans_BRm] = _trans_cube_RDm_inverse, + [_trans_BDr] = _trans_cube_BDr_inverse, + [_trans_BDm] = _trans_cube_BDm_inverse, + [_trans_BLr] = _trans_cube_RDr_inverse, + [_trans_BLm] = _trans_cube_LDm_inverse, +}; + +_static cube_t +transform_edges(cube_t c, uint8_t t) { - switch (t) { - case _trans_UFr: - return _trans_edges_rotation(UFr, c); - case _trans_ULr: - return _trans_edges_rotation(ULr, c); - case _trans_UBr: - return _trans_edges_rotation(UBr, c); - case _trans_URr: - return _trans_edges_rotation(URr, c); - case _trans_DFr: - return _trans_edges_rotation(DFr, c); - case _trans_DLr: - return _trans_edges_rotation(DLr, c); - case _trans_DBr: - return _trans_edges_rotation(DBr, c); - case _trans_DRr: - return _trans_edges_rotation(DRr, c); - case _trans_RUr: - return _trans_edges_rotation(RUr, c); - case _trans_RFr: - return _trans_edges_rotation(RFr, c); - case _trans_RDr: - return _trans_edges_rotation(RDr, c); - case _trans_RBr: - return _trans_edges_rotation(RBr, c); - case _trans_LUr: - return _trans_edges_rotation(LUr, c); - case _trans_LFr: - return _trans_edges_rotation(LFr, c); - case _trans_LDr: - return _trans_edges_rotation(LDr, c); - case _trans_LBr: - return _trans_edges_rotation(LBr, c); - case _trans_FUr: - return _trans_edges_rotation(FUr, c); - case _trans_FRr: - return _trans_edges_rotation(FRr, c); - case _trans_FDr: - return _trans_edges_rotation(FDr, c); - case _trans_FLr: - return _trans_edges_rotation(FLr, c); - case _trans_BUr: - return _trans_edges_rotation(BUr, c); - case _trans_BRr: - return _trans_edges_rotation(BRr, c); - case _trans_BDr: - return _trans_edges_rotation(BDr, c); - case _trans_BLr: - return _trans_edges_rotation(BLr, c); - case _trans_UFm: - return _trans_edges_mirrored(UFm, c); - case _trans_ULm: - return _trans_edges_mirrored(ULm, c); - case _trans_UBm: - return _trans_edges_mirrored(UBm, c); - case _trans_URm: - return _trans_edges_mirrored(URm, c); - case _trans_DFm: - return _trans_edges_mirrored(DFm, c); - case _trans_DLm: - return _trans_edges_mirrored(DLm, c); - case _trans_DBm: - return _trans_edges_mirrored(DBm, c); - case _trans_DRm: - return _trans_edges_mirrored(DRm, c); - case _trans_RUm: - return _trans_edges_mirrored(RUm, c); - case _trans_RFm: - return _trans_edges_mirrored(RFm, c); - case _trans_RDm: - return _trans_edges_mirrored(RDm, c); - case _trans_RBm: - return _trans_edges_mirrored(RBm, c); - case _trans_LUm: - return _trans_edges_mirrored(LUm, c); - case _trans_LFm: - return _trans_edges_mirrored(LFm, c); - case _trans_LDm: - return _trans_edges_mirrored(LDm, c); - case _trans_LBm: - return _trans_edges_mirrored(LBm, c); - case _trans_FUm: - return _trans_edges_mirrored(FUm, c); - case _trans_FRm: - return _trans_edges_mirrored(FRm, c); - case _trans_FDm: - return _trans_edges_mirrored(FDm, c); - case _trans_FLm: - return _trans_edges_mirrored(FLm, c); - case _trans_BUm: - return _trans_edges_mirrored(BUm, c); - case _trans_BRm: - return _trans_edges_mirrored(BRm, c); - case _trans_BDm: - return _trans_edges_mirrored(BDm, c); - case _trans_BLm: - return _trans_edges_mirrored(BLm, c); - default: - DBG_LOG("transform error, unknown transformation\n"); - return zero_fast; - } + cube_t ret, trans_cube, trans_inv; + + DBG_ASSERT(t < 48, zero, + "transform: invalid transformation %" PRIu8 + ", must be between 0 and 47\n", t); + + trans_cube = cube_trans_table[t]; + trans_inv = cube_trans_table_inverse[t]; + + ret = compose_edges(trans_cube, c); + ret = compose_edges(ret, trans_inv); + + return ret; } -_static cube_fast_t -transform_corners(cube_fast_t c, uint8_t t) +_static cube_t +transform_corners(cube_t c, uint8_t t) { - switch (t) { - case _trans_UFr: - return _trans_corners_rotation(UFr, c); - case _trans_ULr: - return _trans_corners_rotation(ULr, c); - case _trans_UBr: - return _trans_corners_rotation(UBr, c); - case _trans_URr: - return _trans_corners_rotation(URr, c); - case _trans_DFr: - return _trans_corners_rotation(DFr, c); - case _trans_DLr: - return _trans_corners_rotation(DLr, c); - case _trans_DBr: - return _trans_corners_rotation(DBr, c); - case _trans_DRr: - return _trans_corners_rotation(DRr, c); - case _trans_RUr: - return _trans_corners_rotation(RUr, c); - case _trans_RFr: - return _trans_corners_rotation(RFr, c); - case _trans_RDr: - return _trans_corners_rotation(RDr, c); - case _trans_RBr: - return _trans_corners_rotation(RBr, c); - case _trans_LUr: - return _trans_corners_rotation(LUr, c); - case _trans_LFr: - return _trans_corners_rotation(LFr, c); - case _trans_LDr: - return _trans_corners_rotation(LDr, c); - case _trans_LBr: - return _trans_corners_rotation(LBr, c); - case _trans_FUr: - return _trans_corners_rotation(FUr, c); - case _trans_FRr: - return _trans_corners_rotation(FRr, c); - case _trans_FDr: - return _trans_corners_rotation(FDr, c); - case _trans_FLr: - return _trans_corners_rotation(FLr, c); - case _trans_BUr: - return _trans_corners_rotation(BUr, c); - case _trans_BRr: - return _trans_corners_rotation(BRr, c); - case _trans_BDr: - return _trans_corners_rotation(BDr, c); - case _trans_BLr: - return _trans_corners_rotation(BLr, c); - case _trans_UFm: - return _trans_corners_mirrored(UFm, c); - case _trans_ULm: - return _trans_corners_mirrored(ULm, c); - case _trans_UBm: - return _trans_corners_mirrored(UBm, c); - case _trans_URm: - return _trans_corners_mirrored(URm, c); - case _trans_DFm: - return _trans_corners_mirrored(DFm, c); - case _trans_DLm: - return _trans_corners_mirrored(DLm, c); - case _trans_DBm: - return _trans_corners_mirrored(DBm, c); - case _trans_DRm: - return _trans_corners_mirrored(DRm, c); - case _trans_RUm: - return _trans_corners_mirrored(RUm, c); - case _trans_RFm: - return _trans_corners_mirrored(RFm, c); - case _trans_RDm: - return _trans_corners_mirrored(RDm, c); - case _trans_RBm: - return _trans_corners_mirrored(RBm, c); - case _trans_LUm: - return _trans_corners_mirrored(LUm, c); - case _trans_LFm: - return _trans_corners_mirrored(LFm, c); - case _trans_LDm: - return _trans_corners_mirrored(LDm, c); - case _trans_LBm: - return _trans_corners_mirrored(LBm, c); - case _trans_FUm: - return _trans_corners_mirrored(FUm, c); - case _trans_FRm: - return _trans_corners_mirrored(FRm, c); - case _trans_FDm: - return _trans_corners_mirrored(FDm, c); - case _trans_FLm: - return _trans_corners_mirrored(FLm, c); - case _trans_BUm: - return _trans_corners_mirrored(BUm, c); - case _trans_BRm: - return _trans_corners_mirrored(BRm, c); - case _trans_BDm: - return _trans_corners_mirrored(BDm, c); - case _trans_BLm: - return _trans_corners_mirrored(BLm, c); - default: - DBG_LOG("transform error, unknown transformation\n"); - return zero_fast; - } + cube_t ret, trans_cube, trans_inv; + + DBG_ASSERT(t < 48, zero, + "transform: invalid transformation %" PRIu8 + ", must be between 0 and 47\n", t); + + trans_cube = cube_trans_table[t]; + trans_inv = cube_trans_table_inverse[t]; + + ret = compose_corners(trans_cube, c); + ret = compose_corners(ret, trans_inv); + + return t < 24 ? ret : invertco(ret); } -_static cube_fast_t -transform(cube_fast_t c, uint8_t t) +_static cube_t +transform(cube_t c, uint8_t t) { - switch (t) { - case _trans_UFr: - return _trans_rotation(UFr, c); - case _trans_ULr: - return _trans_rotation(ULr, c); - case _trans_UBr: - return _trans_rotation(UBr, c); - case _trans_URr: - return _trans_rotation(URr, c); - case _trans_DFr: - return _trans_rotation(DFr, c); - case _trans_DLr: - return _trans_rotation(DLr, c); - case _trans_DBr: - return _trans_rotation(DBr, c); - case _trans_DRr: - return _trans_rotation(DRr, c); - case _trans_RUr: - return _trans_rotation(RUr, c); - case _trans_RFr: - return _trans_rotation(RFr, c); - case _trans_RDr: - return _trans_rotation(RDr, c); - case _trans_RBr: - return _trans_rotation(RBr, c); - case _trans_LUr: - return _trans_rotation(LUr, c); - case _trans_LFr: - return _trans_rotation(LFr, c); - case _trans_LDr: - return _trans_rotation(LDr, c); - case _trans_LBr: - return _trans_rotation(LBr, c); - case _trans_FUr: - return _trans_rotation(FUr, c); - case _trans_FRr: - return _trans_rotation(FRr, c); - case _trans_FDr: - return _trans_rotation(FDr, c); - case _trans_FLr: - return _trans_rotation(FLr, c); - case _trans_BUr: - return _trans_rotation(BUr, c); - case _trans_BRr: - return _trans_rotation(BRr, c); - case _trans_BDr: - return _trans_rotation(BDr, c); - case _trans_BLr: - return _trans_rotation(BLr, c); - case _trans_UFm: - return _trans_mirrored(UFm, c); - case _trans_ULm: - return _trans_mirrored(ULm, c); - case _trans_UBm: - return _trans_mirrored(UBm, c); - case _trans_URm: - return _trans_mirrored(URm, c); - case _trans_DFm: - return _trans_mirrored(DFm, c); - case _trans_DLm: - return _trans_mirrored(DLm, c); - case _trans_DBm: - return _trans_mirrored(DBm, c); - case _trans_DRm: - return _trans_mirrored(DRm, c); - case _trans_RUm: - return _trans_mirrored(RUm, c); - case _trans_RFm: - return _trans_mirrored(RFm, c); - case _trans_RDm: - return _trans_mirrored(RDm, c); - case _trans_RBm: - return _trans_mirrored(RBm, c); - case _trans_LUm: - return _trans_mirrored(LUm, c); - case _trans_LFm: - return _trans_mirrored(LFm, c); - case _trans_LDm: - return _trans_mirrored(LDm, c); - case _trans_LBm: - return _trans_mirrored(LBm, c); - case _trans_FUm: - return _trans_mirrored(FUm, c); - case _trans_FRm: - return _trans_mirrored(FRm, c); - case _trans_FDm: - return _trans_mirrored(FDm, c); - case _trans_FLm: - return _trans_mirrored(FLm, c); - case _trans_BUm: - return _trans_mirrored(BUm, c); - case _trans_BRm: - return _trans_mirrored(BRm, c); - case _trans_BDm: - return _trans_mirrored(BDm, c); - case _trans_BLm: - return _trans_mirrored(BLm, c); - default: - DBG_LOG("transform error, unknown transformation\n"); - return zero_fast; - } + cube_t ret, trans_cube, trans_inv; + + DBG_ASSERT(t < 48, zero, + "transform: invalid transformation %" PRIu8 + ", must be between 0 and 47\n", t); + + trans_cube = cube_trans_table[t]; + trans_inv = cube_trans_table_inverse[t]; + + ret = compose(trans_cube, c); + ret = compose(ret, trans_inv); + + return t < 24 ? ret : invertco(ret); } -- cgit v1.3