Playing with Particles on the PSP

Unfortunately I have been unabled to get pictures of the programs so far; however I am still currently trying to get some video capture of them done.

Billboard Particle System (PSP)

This was a follow up from a previous module where we created a 3D scene on the PSP (which can be found here). Once again this program was written in C, using Sony’s PSP development kits. The module specification only required us to display bill boarded textured particles, and then it allowed us to do what we wanted in terms of scene. Due to problems, I had to start this assignment later than what I wanted and it only allowed me 4 days to work on both this and a benchmarking tool. The billboarding method I used was to create a world transformation based on the particles location to the camera; the tutorial I used can be found at http://nehe.gamedev.net/article/billboarding_how_to/18011/.

When playing around with the movement I saw that the particles looked a bit like fireworks, so I played on this a bit and made a small firework display revolving around user interaction. Four fireworks are available to be fired using the face buttons. Each time the button is pressed a new particle is created at a random point with a random lifespan, it then moves up and once its lifetime ends, it explodes into around 50-200 new particles depending on the type. It also uses different colours, bringing a bit more to life to the scene.

The camera can also be moved around, and the scene paused – this was more to aid the lecturer in seeing the billboarding in action.

Benchmarking Application (PSP)

Again this was written in C and made using Sony’s PSP development kits. This was also written in the four days along with the particle system.

The aim of this was to get some quantifiable data from the PSP in terms of memory allocation, render time and FPS. To do this I had to create a small Vector Matrix library in C, by doing this I can make sure that the calculations are done on the CPU, and that I know exactly what is happening each loop. Each render loop I then rotate a number of quads around three axis’s and display them. You can also increase the number of quads via controls.

Once I had a basic application complete, I recorded some results from using multiple numbers of quads (test FPS at 50, 100, 150 quads etc). I then put it into a table and analysed the results. Because someone other students are still working on this, I am unable to post the results / what I found out.

Comments

Post a Comment

Popular posts from this blog

3D Game Engine Using DirectX11 (C++)

Image
This piece of work is what I’m most proud of this semester; it is also one of the projects I had the most fun working on; and because of that, I am currently building upon it and plan to continue over the summer. This is the first time I have ever used a 3D engine, or attempted building my own framework. Framework The engine uses a scene graph to handle the objects in the scene; once the user creates one of the nodes and adds it to the graph, the Initialisation, Updating and Rendering is handled in the underlying framework. I tried to make it so that the user would be able to simply add something to the scene, whilst maintaining as much control as possible. The user is able to create and add a node using 2 lines of code; this then adds the object to the scene graph and everything is handled in the under lying code, the result of this code would load, update and render that object onto the window. The Renderer is what I’ve used as the main DirectX interface...
Read more

MIPS Graphics Library

Image
The reason for this task is twofold: first it helped show me show much work the processor had to do to display a simple shape on the screen; it also taught me memory management. The program was written in MARS virtual environment, and uses the Bitmap display to give a visual representation of the code. Each method uses 4 memory addresses to pass parameters, if any more are needed then they are sent to the stack.  The “SetPixel” method is the simplest, it takes the X, Y and colour of the pixel – calculates it position on the screen and then stores the colour into the memory address into the location where the screen gets its information.  The “DrawLine” method uses Bresenham’s Line algorithm. It takes a start point and end point of the line as parameters, as well as the colour. It then works out the gradient of the line, plots the first pixel, and then adds the gradient again to get to the next pixel. This repeats until it has reached the second point. The “Dr...
Read more

3D Renderer (C++)

Image
This is a 3D renderer that I wrote in C++ to load in and display “.md2” files, a fairly old format but a good basis into understanding graphics programming. An “.md2” file merely a list of vertices based around an origin, and a set of 3 integers which is loaded in as a polygon. A polygon contains 3 indexes, each point to a vertex in a list, contained within the model. This means that if a vertex is used more than once, it won’t be duplicated. The program started off with “Vertex” and “Matrix” classes which held the instructions to multiply them together; this is the basis of transforming and viewing the vertices on the screen. Once we had these, we could implement the full viewing pipeline, using perspective projection. And after this we could visually display these points on screen. To begin with I focused more on transformations and camera positioning whilst I had the points showing in world space. To visually show the model I made a “DrawWireFrame” method which drew lines...
Read more