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.
The demoscene project was created 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.
The Perlin noise algorithm is expensive on the CPU (even with FPU optimised operations), which caused the main thread of the application to be blocked until the function had completed its operation. This was optimized using a combination of multi-threading and library intrinsic functions available for the FPU.
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. The generated data between the 20 frames was then interpolated, to reduce the computational overhead of creating an entirely new pattern.
The on-board 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. This is because the intrinsic functions that were provided as part of the PSP SDK for enabling developers to conveniently execute mathematical operations on the FPU that is a part of the PSP's hardware.
- 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 (FPU)
- Utilisation of the PlayStation Portables FPU libraries enabling for faster generation of images.