Proposal

Introduction

The overall aim for the project is to research and experiment into different methods of deforming meshes in real time while making the deforming meshes seem realistic. The program needs to be also optimised so that it doesn’t take a lot of memory to run and can be placed as minor effect file into a larger program. It must also have force working against the deformity to make sure that the deformity will be realistic and not force the object to deform completely and then later be able to return to their original state.

Motivation

The reason behind wanting to do this is because it relies heavily on the physics side of programming which is something I enjoy working with. Due to alot of the forces acting on the object means that there will be multiple equations necessary to get the object to behave like it should in real life situations. The project is also based around the manipulation of the object’s meshes which is something I have very little practice in doing and so it will be interesting to see how I can possibly work with manipulating meshes of the loaded in objects.

I can see this being an interesting project to others as it will be based around the manipulation of objects this itself is something not used often in games and if I can make the program run at a good optimised rate then it could possibly be used within an engine to simulate the changing of objects shapes and size.

Issues

The issues of which I wish to address are based around the use of deforming meshes in games. This means that the meshes must be capable to being deformed in a realistic manner and the object must not be capable of deforming the mesh into something which cannot happen in real time terms. Due to the need for user input on the object, the meshes must be capable of being changed wherever the user interacts with the object and be able to take multiple deformation of the object at one time. The object must also be affected by the forces so tension must work against the users input and a coefficient used to base the equation around the different effects of different materials of which these objects will be based around. This also means that specific objects must be capable of reforming itself after the user has removed any force placed upon the object. The project must also be capable of being introduced into a larger product and not take up too much memory so that the program can run other items based around the game itself. Thus this means that the program must be optimised as much as they possibly can.


Research question

Is it possible to produce an optimized program which can allow the user to deform a rendered object and that object to return to its original state in real time?

Addressing the question

To answer this question research must been done into the different methods of changing meshes in real-time in a program. As of this time I have already found multiple methods and from the ones of which I have found so far the Jacobin matrix shader method seems the most suitable for what I am trying to produce. While this method would be useful for producing my product it does not have any sort of interaction with the user which is something which I want to include in my end product. This means that I will need to look into the different equations used to find the forces which affect the object when pressure is placed onto it. These equations must also be flexible so that the coefficient in the pressure placed on the object can be changed.

Although there are things already needing to be looked into, experimented with and implemented into a working product. There still multiple ways of furthering answering the question at hand by introducing different effects and methods into the product. The first of which is by being able to change the texture of the object of which is being pushed on. This will have a different effect on the forces placed onto the object and thus the possibility of different outcomes (i.e. shattering the mesh instead of deforming). This means that to allow the program to work I’ll need to look into the creating a setup where the textures of the objects can be chosen and the values of these will affect the outcome of the forces placed upon the object. I will also need to look into splitting meshes which will be complicated and while close to the wanted objective of this product is too much unnecessary work when the wanted product can be produced using easier methods. These ideas are possibilities of furthering the product and giving a better depth into answering the question asked for this product.

I will also need to experiment around with the methods for multiple reasons. First of all I will need to use trial and error to understand how the methods work and how I can change the program to fit to my criteria’s. The next thing I will need to experiment on is in ways of which pressure can be applied to object and the effects it has on the object. The force and pressure applied onto the object must act as realistically as possible and so I will need to test the equations to make sure they are producing a realistic outcome. Finally I’ll need to optimise the program so that the program could be easily implemented into another program and not take up too much memory while producing its effect. This means that certain lines of code will need to be taken out or changed to run smoother and optimising techniques will be needed to be implemented. These techniques need to be tested beforehand to make sure that they will affect the fps the way that I want it to.


Progress

I have made a lot of progress in the research of my project. At the moment I have found three distinct ways of reproducing the process of deformity in the meshes each have their own advantages and disadvantages to them in reproducing the end product which is necessary.

The first method which could be used to reproduce the end results necessary would be the radial basis function method. From the research I have looked into I can see that the radial basis function works fairly similar to that of Bezier curves. This means that the methods uses control points in specific places and will change the formation of the object depending on where the controls points are. This is by the far the easiest to implement and to obtain the wanted required results out all of the methods of which I have found but it has some major problems. This mainly being that the deformation of which this method is capable of deforming is too limited to the amount of deformation that will be necessary for the end product and it is also the most memory consuming of the methods I have found.

The next method of note is the finite element method. This method by far seems to be the most effective method that I have found so far as this method is capable of splitting any object and also allow said object to merge with other meshes to create one object if necessary. This method is also capable of affecting multiple meshes at multiple times without too much of an effect on the processing speed of the program itself. Unfortunately this method is extremely complicated and needs the use of multiple different equations and methods to get working and with the amount of time available to produce our end product means that this method is not possible to be reproducing to give a good end result. It has also been recommended that I stay away from this method due to the level of mathematics necessary to produce the end result.

The final method which I will most likely be using to produce the end results is basically a midpoint between the two previous methods. This method is the Jacobin matrices shader method. This method makes use of the geometry shader which is available in the directX 10 software development kit (SDK). The way that the geometry shader works is that the shader will take in the necessary data on the objects mesh and then differentiate the values into a grid and then smooth out the value to create the deformation more realistic. The end result of this is different from the wanted result so a lot of experimentation will be necessary to achieve this. The method here is very similar to what is needed and it is also shader based, meaning it can easily be implemented into multiple different projects and allow them to run easily without too much change to the necessary code, needed to deform the mesh. It should be noted that due to the fact that XP does not use directX 10 could make things much harder than necessarily need to be.

It should also be noted that I have had a quick look into the necessary equation which would be used to find the elasticity of an object but as of this time I have not had that many breakthroughs with the elasticity equations and will continue to look further into these equations

Resource requirements

I will need a compiler to run this project preferably visual studio C++ and I will also need an application programming interface (API) to write my program. I will probably write my program in openGL but will also take directX into context as well. Using these I will be able to produce my final product.

While I have an overall idea on how to make my meshes deform I still need to do a lot more research into the subject. To do this I will most probably need the use of multiple books to find out some of the necessary equations needed to make the deforming of the meshes as realistic as possible. I will also need the internet to find tutorials on specific problems or to find scholar papers which are relatively close to my own project so I can further my research into the methods of which can be used to achieve my goal and thus either find a better method in getting my end result or improving on the method which I at the moment plan on using.

There are also other things which could also help with the production of the end product. These being mainly objects of which the program plans to imitate. The first which would be imitated will be a stress ball so it would be best if I get hold of stress ball. By using the stress ball as an example I can then test the program to make sure that the program is doing what it is supposed to be doing by comparing it to its real-life object. This will allow me to easily produce a more realistic end product.
References and Bibliography

(Chris Wojtan 2009, Guinot 2006, Noe 2009, Goc 2005)

Chris Wojtan, N. T., Markus Gross, and Greg Turk. 2009. Deforming meshes that split and merge. [online]. SIGGRAPH. Available from: http://www.cc.gatech.edu/~wojtan/topo_goop/topo_goop.html [Accessed 29th September 2009].

Goc, R. 2005. Elasticity: Physics. [online]. Physics Tutorial by Roman Goc. Available from: http://www.staff.amu.edu.pl/~romangoc/M10-elasticity.html [Accessed 26th November 2010].

Guinot, J. 2006. oZone3D.net Tutorials: Mesh Deformers in GLSL. [online]. oZone3D.net. Available from: http://www.ozone3d.net/tutorials/mesh_deformer.php [Accessed 29th September 2010].

Noe, K. 2009. Computer Graphics Lab: Noe's tutorial on deforming 3D geometry using RBFs. [online]. Alexandra Institute. Available from: http://cg.alexandra.dk/2009/08/14/deforming-geometry-using-radial-basis-functions/ [Accessed 29th September 2010].