PSP SDK Perlin Noise FPU Demo
This developed as part of a project for my university degree. The end result was a demoscene application that demonstrated the usage of Perlin (Simplex) Noise generation under 4096 bytes of instruction size and 1024 bytes of data on the PSP. This was to be done on the PlayStation Portable kits that we had available and written in the C language.
As such, I went about creating my demo revolving around the Perlin Noise algorithm. My project in particular utilised a variation of the algorithm called "Simplex Noise" that enabled for smoother generation of noise with less instruction size.
Due to the algorithm being highly expensive on the CPU (even with FPU offloaded calculations), it meant that it caused the process of the application to be blocked until the function had completed its cycle. To avoid this, I made use of multi-threading with the SCE libs that were made available for the platform. The result was better and as such I managed to get rid of the blocking problem that was initially causing my binary to take a while to load on the PSP. Instead, I was receiving visual updates as to what point of loading the textures had gotten to, as opposed to prevent the rest of the program executing its code.
Utilizing the srand() function (as a part of math.h) it meant that during the generation of the perlin noise textures, it was incremental in appearance. This ultimately meaning that the end result was something similar to a blob like effect over the course of 20 frames.
Additionally, the onboard FPU of the PSP enables for floating point calculations to be done considerably faster than they would be if they were done entirely with the likes of the math.h library that comes as part of standard C.
Although I am not allowed to reveal what functions within the libraries were used due to NDA restrictions, I can ultimately say that making calls to the FPU through the Sony library optimised the generation time significantly of the noise patterns.
The technical design documentation for this project can be found here.
- Threading: Multi-threaded noise generation preventing blocking on main thread.
- Procedural Generation: Interpolation between noise data enabling for longer animations using less data.
- Floating-point Processing Unit: Utilization of the PlayStation Portables FPU libraries enabling for faster generation of images.