ArduboyLUTs (float)

//CONSTANTS are from: https://github.com/ulfben/ArduboyRayCaster/blob/master/Config.h

// tangent tables equivalent to slopes, used to compute initial intersections with ray
std::array<float, ANGLE_360> tan_table;
std::array<float, ANGLE_360> inv_tan_table;

// step tables used to find next intersection, equivalent to slopes times width and height of cell
std::array<float, ANGLE_360> y_step;
std::array<float, ANGLE_360> x_step;

// 1/cos and 1/sin tables used to compute distance of intersection very quickly
// Optimization: cos(X) == sin(X+90), so for cos lookups we can simply re-use the sin-table with an offset of ANGLE_90.
std::array<float, ANGLE_360 + ANGLE_90> inv_sin_table; //+90 degrees to make room for the tail-end of the offset cos values.
float* inv_cos_table = &inv_sin_table[ANGLE_90]; //cos(X) == sin(X+90).

// cos table used to fix view distortion caused by radial projection (eg: cancel out fishbowl effect)
std::array<float, HALF_FOV_ANGLE * 2> cos_table;

constexpr inline bool isFacingLeft(const int view_angle) const noexcept {
    return (view_angle >= ANGLE_90 && view_angle < ANGLE_270);
}
constexpr inline bool isFacingRight(const int view_angle) const noexcept {
    return (view_angle < ANGLE_90 || view_angle >= ANGLE_270);
}
constexpr inline bool isFacingDown(const int view_angle) const noexcept {
    return (view_angle >= ANGLE_0 && view_angle < ANGLE_180);
}
constexpr inline bool isFacingUp(const int view_angle) const noexcept {
    return (view_angle >= ANGLE_180 && view_angle < ANGLE_360);
}

void buildLookupTables() noexcept {
    constexpr auto TENTH_OF_A_RADIAN = ANGLE_TO_RADIANS * 0.1f;
    for (int ang = ANGLE_0; ang < ANGLE_360; ang++) {
        const auto rad_angle = TENTH_OF_A_RADIAN + (ang * ANGLE_TO_RADIANS); //adding a small offset to avoid edge cases with 0.
        tan_table[ang] = std::tan(rad_angle);
        inv_tan_table[ang] = 1.0f / tan_table[ang];
        inv_sin_table[ang] = 1.0f / std::sin(rad_angle);

        // tangent has the incorrect signs in all quadrants except 1, so manually fix the signs of each quadrant.
        if (isFacingDown(ang)) {
            y_step[ang] = std::abs(tan_table[ang] * CELL_SIZE);
        } else {
            assert(isFacingUp(ang) && "isFacingUp() should be the exact inverse of isFacingDown(). Have you changed the coordinate system?");
            y_step[ang] = -std::abs(tan_table[ang] * CELL_SIZE);
        }
        if (isFacingLeft(ang)) {
            x_step[ang] = -std::abs(inv_tan_table[ang] * CELL_SIZE);
        } else {
            assert(isFacingRight(ang) && "isFacingRight() should be the exact inverse of isFacingDown(). Have you changed the coordinate system?");
            x_step[ang] = std::abs(inv_tan_table[ang] * CELL_SIZE);
        }
        assert(std::fabs(y_step[ang]) != 0.0f && "Potential asymtotic ray on the y-axis produced while building lookup tables.");
        assert(std::fabs(x_step[ang]) != 0.0f && "Potential asymtotic ray on the x-axis produced while building lookup tables.");
    }

    //duplicate the first 90 sin values at the end of the array, to complete the joint sin & cos lookup table.
    auto end = std::end(inv_sin_table) - ANGLE_90;
    std::copy_n(std::begin(inv_sin_table), ANGLE_90, end);

    // create view filter table. Without this we would see a fishbowl effect. There is a cosine wave modulated on top of the view distance as a side effect of casting from a fixed point.
    // to cancel this effect out, we multiple by the inverse of the cosine and the result is the proper scale.
    // inverse cosine would be 1/cos(rad_angle), but 1 is too small to give us good sized slivers, hence the constant K which is arbitrarily chosen for what looks good.
    for (int ang = -HALF_FOV_ANGLE; ang < HALF_FOV_ANGLE; ang++) {
        const auto rad_angle = TENTH_OF_A_RADIAN + (ang * ANGLE_TO_RADIANS);
        const auto index = ang + HALF_FOV_ANGLE;
        cos_table[index] = (K / std::cos(rad_angle));
    }
}

template <class Container>
[[nodiscard]] std::string join(const Container values, std::string delimiter = ","s){
    using T = typename Container::value_type;
    return std::accumulate(
        std::begin(values),
        std::end(values),
        std::string(),
        [delimiter](std::string a, T b) -> std::string {
            std::string delim(a.length() > 0 ? delimiter : ""s);
            return a + delim + std::to_string(b);
    });
}

template<typename T>
void printTableDefinition(const char* name, const T table, const size_t size) const noexcept {
    //std::cout << "std::array<float, " << size << "> " << name << "{\n"; //PC
    std::cout << "constexpr float " << name << "[" << size << "] PROGMEM {\n"; //ArduBoy
    std::cout << "\t" << join(table, size, "f,");
    std::cout << "f};\n";
}

void prettyPrintLUTs() noexcept {
    printTableDefinition("tan_table", tan_table, tan_table.size());
    printTableDefinition("y_step", y_step, y_step.size());
    printTableDefinition("x_step", x_step, x_step.size());
    printTableDefinition("inv_sin_table", inv_sin_table, inv_sin_table.size());
    printTableDefinition("inv_tan_table", inv_tan_table, inv_tan_table.size());
    printTableDefinition("cos_table", cos_table, cos_table.size());
    std::cout << "const float* inv_cos_table = &inv_sin_table[" << ANGLE_90 << "];\n";
}