NDS Renderer

We are currently working on an optimized 3D renderer for the NDS. The NDS is the most complicated (retro) console I have worked on to date due to its complex hardware layout and multiple hardware faults. This means that we can't rely on an emulator and have to test performance much more on the hardware directly. 

The NDS has a fixed stage 3D rendering pipeline which is limited by how well we can pack 3D rendering data. I have been responsible for improving our data packing by implementing a triangle stripping algorithm. Further more, I have worked on creating a tool to convert OBJ models to a custom format for the NDS. This involves understanding the NDS 3D commands and texture format.

NDS Ray tracing

One of my interests has been in bringing ray tracing to the NDS. Ray tracing is very performance heavy, and therefore a very interesting case to optimize very low level.

While I was learning how to write a ray tracer, the demo scene was a useful source as they have used ray tracing since before the NDS. From this I learned to implement screen space subdivision which brought a large performance improvement.

I also learned to optimize calculations using fixed point math as the NDS has no floating-point capabilities. Another large optimization was manipulating the cache by loading and locking cache lines on the NDS. For this I had to learn to read through the ARM9 processor manual. Lastly, I'm currently looking into further improving performance by running multiple processors in parallel.

GBA Renderer

The first retro project we worked on was a 3D renderer for the GBA. The GBA has no 3D rendering or floating-point capabilities, so instead we implemented our own software renderer to draw directly to the screen. No SDK was used, which meant we had to do a lot of research in order to write directly to hardware addresses.

For this project I was mainly responsible for optimizations. This means I brought algorithmic optimizations and took the C/C++ code and converted it into assembly. I also implemented a runtime code switching system to save on memory and prevent the performance impact branching has.