This will be a short but sweet post, unlike my usual novel length posts :)
Lets get it started then. I saw something really cool today, mesh deformation with Unity. Now as you know, Unity has supported soft bodies since Unity 3 was rolled out. Specifically, simulating cloth is literally add component, move sliders, done (in a nuthshell). However, I've seen a few examples dotted around the net of non-planar mesh deformation within Unity, but not many. Here is a good example, for those of you that want to look through some code (which is always the best way to learn) :)
Seeing mesh deformation in action within Unity, and having enjoyed making a cloth simulation in the past (and generally all things physics). I thought I'll dub my Wednesday, "Mesh Deformation Day", and see if I can make my own. I'll keep it basic and literally go for a click here, and translate the vertices of mesh down (along the y-axis) as a proof of concept. It'll basically be an experiment (aka "playtime") to see what I can come up with :) - I'll keep you posted!
Right, it's just been under two months since I completed my masters project, and I thought I'd do a sort of "review/feedback round-up" of the websites it got reviewed on, and what the gaming community had to say about it.
Well firstly, it gathered much more attention than I thought it would. Within the space of 5 weeks, since uploading to YouTube it has gathered just over 13,000 views. It also featured on roughly 15 or so websites, with all positive reviews (which is surprising, since I expected a few mixed ones too - which I did get from quite a few gamers).
The project was featured on various Kinect developer community websites. Links to the some of the reviews can be seen below.
Dashhacks - "Kinect and Unity3D First Person Shooter"
123 Kinect - "Student Shows That Kinect and Gamepad Work Pretty Well"
Kinectaku - "Masters Project Shows How Hybrid Games Should Work"
Kinect Hacks - "Hybrid Control Scheme Using an Xbox Game Pad and Kinect"
Hack-a-day - "Hybrid Control Scheme Using an Xbox Game and Kinect"
I created a digital asset in Houdini to procedurally generate cities, gardens or custom layouts (i.e. the terrain's texture can be modified and the asset models can be specified by the user, to be used within the custom layout).
The user operates the tool via a developed GUI, using sliders and text input boxes to specify the layout (city, garden or custom) they desire. The user then enters their specified parameters via the GUI, which will in turn procedually generate their requested layout. The node network the digital assets uses, can be seen below.
The node network the digital asset uses can be seen on the left-hand side of the image (above). The city the tool has procedurally generated can be seen on the right-hand side.
The digital asset tool GUI can be seen left-hand side of the image, below. The garden procedually generated by the tool can be seen on the right-hand side.
The custom layout can be seen on the right-hand side of the image (above). The user can specify the terrain's textures and the models used within the layout, via the digital tool's GUI (on the left-hand side of the image),
A cloth simulation was written as a part of my CGI Technology module on my degree. Initial research was conducted on how a piece of cloth physically behaviours in the real world. Previous works were also researched, and their methods scrutinised, to find the most appropriate method for this cloth simulation (i.e. taking time constraints into consideration).
The spring-mass-damper model was chosen to physically represent the piece of cloth, as this is the most established/used model, and also provides better results over cruder constraint-only models. Forward Euler and Verlet integration techniques were also chosen to integrate the cloth. However, RK4 integration was not included due to time constraints (the project's duration was 3 and half weeks) although I would have liked to implement it (and shall do at a later date).
For more information, with regards to how the project was implement see the report (below). Additionally, a demonstration video has also been included (see below).
Note: At some points it looks like the cloth is going wild/glitching. However, this simply occurs when changing the user changes the constraint points. When modifying the constraint points, the cloth needs to stabilizing itself, until it reaches it's natural equilibrium.
As part of my personal inquiry module at University, I decided I wanted to make a game that specifically used the Microsoft Kinect. Having recently read (at the time) that the Kinect had been "hacked" (the usb driver) so that it could be connected via a PC, this sparked my interest to create a Kinect game. Upon doing some research I discovered the company PrimeSense (which developed the Kinect's software with Microsoft) had released their own framework and middleware (OpenNI and NITE, respectively). So after reading through the API documentation a few times, I had got the jist of how the framework worked, and how to develop for it. It was at this point that I made another discovery, PrimeSense had also released a wrapper of OpenNI for Unity (a game engine/creation software, which I used and loved for years).
With OpenNI and NITE in one hand, and Unity in the other, I decided to go to work. The time scale for the project (the deadline I was working to) was 3 weeks, including having other on-going assignments. So I decided on a simple game, which was both enjoyable to play and could be realistically created within 3 weeks (including documentation). The game I came up with was "Gunslingers", a wild west dueling game. The player would play against the computer, by standing in front the screen, and drawing when prompted. The fastest to draw would shoot the other, deducting a life. The first player to 0 lives would lose the game. The game is coded entirely in C#.
The most difficult parts of development were really getting to grips with how OpenNI and NITE worked with Unity (especially when bumping into a barrage of bugs, i.e. if you rotated the player's rig in the editor, the rig would simply break). After getting to grips with OpenNI and NITE, I soon learned several tips and tricks, which sped my workflow exponentially. This allowed more time to be spent on the games' mechanics and the computers AI.
The computer's AI was developed to act exactly the same as a human player (as mostly all game AI's are). Thus, the AI was required to follow the same rules as the player in order to win. The computer would draw at differing speeds dependant on the difficulty the player selected. The computers rig was also animated, when drawing and holstering their gun.
The game also featured a large GUI options menu, where the player could select pre-set difficultly options or individually set the entire function set of the game (i.e. number of lives - for player and computer, draw speed, timer speed etc). Thus, the player could effectively set a handicap, or make the game as difficult, as they wanted.
I felt the project was very successful, considering the time frame. It wasn't as polished as I would have liked to be, but given the fact that I had to learn an the OpenNI framework and NITE API, and then create an entire working game from scratch within 3 weeks, I was very happy. The demonstration of the game at a University poster session, also provided me with a lot of positive feedback from my peers.
I thought about extending this project, however instead I carried the lessons I'd learnt from the project, over to my masters project, which pushed the idea of using the Kinect with Unity a lot further. Therefore, I shall simply leave this project at this point, as it served it's purpose and was ultimately surpassed by my masters project (but will always be remembered as the originator) :)
Note: A side-by-side version (footage of me using the Kinect, and the game) of this video will be uploaded in the near future. However, as my video camera has broken, it may be a few weeks before I'm able to record and upload the new video.
Tuesday, October 25, 2011 at 21:17 ;)
;)
;)