I have a public beta of my 2D/3D/isometric software renderer (currently for Linux). Hopefully I can get some feedback about usability (with valid arguments, not religious references), feature suggestions and find the last bugs before making a 1.0 release from where version compatibility becomes important. Now I can still erase things that should not be in the core library.
I try to keep the style minimalistic and unconventional in order to find a better way to write C++. Old habits have to die, so that both performance and usability can improve. The library does not have any rendering context nor global state, because each resource is reference counted independently. Most of the API uses global functions to improve testability and reduce cyclic dependencies. Classes are mostly hidden internally for running the GUI system.
More desktop/laptop systems can be supported with contributions, but I only have different Linux distributions on my 10 computers, because Microsoft abandoned their last stable release (Windows 7). Android and IOS will not be supported, because this project focuses on long-term stability over centuries, not months.
It does not link dynamically to any third-party library. No 3D accelerated drivers nor OpenGL extensions required to function, just the bare minimum of the operating system. Window managers are optionally linked from the outside as a single module so that platforms in a distant future can easily be ported to. If you don't want a window manager at all, you can convert the image into ascii art or write to an image file.
Both SSE2 and NEON are supported with a portable hardware abstraction layer for SIMD. Infix syntax generates code for the target system with the same speed as hand-written intrinsics, but testing on one platform almost guarantees that it will work on other platforms as well. I have profiled and inspected the generated assembly code to make sure that there is no overhead from the abstraction.
The isometric deferred light (main feature) is demonstrated in the Sandbox SDK example.
* Each model is pre-rendered with millions of polygons into diffuse, normal and height images.
* A low-detail 3D model is stored with the images for casting dynamic shadows.
* Sprites that rarely move are buffered using garbage collected background blocks that draw fixed sprites from an oc-tree structure when made visible by the camera.
* Dynamic sprites call the core renderer with diffuse, normal and depth images for deferred light.
* Light sources render the depth images from the low-detail shadow models.
* Light sources draw deferred light to the screen's light image.
* The diffuse and light image is multiplied.
* Multi-threading is used to upload the result using X11 while the next frame does game logic.
The result is around 300 frames per second in 800x600 resolution on a hexa-core CPU while having real-time dynamic light and unlimited detail-level for deep sprites.
Full 3D rendering
The engine also has 3D graphics with bi-linear mipmap sampling and lightmaps. Depth-buffer optimizations for 3D rendering are not yet implemented, because documenting and testing the API comes before doing fun stuff that might break things. Slowly but surely, the library becomes complete.
The GUI system currently has panels, buttons and list-boxes. Write your scalable interface in a file and load it into a window using a single line of C++ code. Have different layouts for different countries and preferences. Using both relative and absolute coordinates allow resizing the interface easily. Add three lines of code to define a lambda function to execute when a button in the interface is pressed.