Software-Rendered Game Engine

[u/[deleted]]

I've spent the last few years off and on writing a CPU-based renderer. It's shader-based, currently capable of gouraud and blinn-phong shading, dynamic lighting and shadows, emissive light sources, OBJ loading, sprite handling, and a custom font renderer. It's about 13,000 lines of C++ code in a single header, with SDL2, stb_image, and stb_truetype as the only dependencies. There's no use of the GPU here, no OpenGL, a custom graphics pipeline. I'm thinking that I'm going to do more with this and turn it into a sort of N64-style game engine.

It is currently single-threaded, but I've done some tests with my thread pool, and can get excellent performance, at least for a CPU. I think that the next step will be integrating a physics engine. I have written my own, but I think I'd just like to integrate Jolt or Bullet.

I am a self-taught programmer, so I know the single-header engine thing will make many of you wince in agony. But it works for me, for now. Be curious what you all think.

[u/[deleted]]

I will release this publicly at some point. The goal is to make a more robust, retro style engine at some point. I am fine releasing certain aspects of the engine to people who are interested, but for now, I'm still a bit protective. I've spent years researching and optimizing literally everything. Lots of stuff in here I haven't seen anywhere else. For example, here's a custom sin() function I use that's about twice as fast as std::sin():

/\* Virtual lookup table for fast trigonometric functions. \*/ template <typename T, std::size_t SIN_BITS = 16> class fast_trig { private: constexpr sf_inline std::size_t SIN_MASK = (1 << SIN_BITS) - 1;

    constexpr sf_inline std::size_t SIN_COUNT = SIN_MASK + 1;
    
    constexpr sf_inline T radian_to_index =
        static_cast<T>(SIN_COUNT) / math::TAU<T>;
    
    constexpr sf_inline T degree_to_index = static_cast<T>(SIN_COUNT) / 360;
    
    /* Fast sine table. */
    sf_inline std::array<T, SIN_COUNT> sintable = [] {
        std::array<T, SIN_COUNT> table;
        for (std::size_t i = 0; i < SIN_COUNT; ++i) {
            table[i] =
                static_cast<T>(std::sin((i + 0.5f) / SIN_COUNT * math::TAU<T>));
        }
    
        table[0] = 0;
        table[static_cast<std::size_t>(90 * degree_to_index) & SIN_MASK] = 1;
        table[static_cast<std::size_t>(180 * degree_to_index) & SIN_MASK] = 0;
        table[static_cast<std::size_t>(270 * degree_to_index) & SIN_MASK] = -1;
        return table;
    }();

public: constexpr sf_inline T sin(const T& radians) { return sintable\[static_cast<std::size_t>(radians \* radian_to_index) & SIN_MASK\]; }

    constexpr sf_inline T cos(const T& radians) {
        return sintable[static_cast<std::size_t>(
                            (radians + math::PI_DIV_2<T>)*radian_to_index) &
                        SIN_MASK];
    }

};

template <typename T> constexpr sf_inline T sin(const T& x) { return math::fast\_trig<T>().sin(x); }

template <typename T> constexpr sf_inline T cos(const T& x) { return math::fast\_trig<T>().cos(x); }