I’m doing three modules this term that I’m really looking forward to doing. They are Team Project, Graphics II and Application Development.

Team Project

Team Project is an opportunity for me to create something great as part of a team. The only real directions we have received is to make something impressive (but feasible). The project doesn’t even necessarily have to be programming based, but as everyone in my Team is studying Computer Games Programming we all really wanted to make a game… So a game it is!

Our team is made up of 6 programmers all in their second year of Games Programming, and from what I could tell from the first meeting we were all looking forward to making something cool.

After talking and  getting to know my team mates the type of game that we wanted to make evolved quickly and we settled on making something 2D in Unity. We picked Unity for it’s quick and professional development environment and we decided to go with a 2D game as we don’t have any artist in our team, and programmer art is never a pretty sight.

I found that I was leading the discussion about the different platforms and games that were available for us to work with and make, so I became  the team’s Project Manager. This means that I’ve become the point of contact between Dave Voorhis (the lecture for this module) and the rest of the team. It also falls to me to organise our team, help delegate tasks and make sure that this project is done on time to a spectacular standard.

The first thing that I did as Project Manager was set Wednesdays as the day that we would all meet up outside of the scheduled tutor time for this module. We were limited on time as one of the team members has to pick up his child from school in the afternoon so we agreed to meet at 10am every Wednesday and work though until then. I have also collected all of the team members’ email addresses should I need to contact them and made a “todo” list  and description of the game and how it will be played on Google Docs.

For now this week the only task on the Todo list is for everyone to lean some Unity! We have a facebook group that people have been posting Unity tutorials in so it looks like things have started smoothly.

I’ll give more information on our project when we have some screen shots and more development news to talk about.

Graphics II

Onto Graphics, I really enjoyed Graphics I last term and I am really looking forward to sinking my teeth into this module. There are three tasks that make up the final grade for Graphics II:

- An 8 page Scientific Paper styled report comparing the two main graphics APIs OpenGL and Direct3D

- A Tech Demo designed to show off my capabilities as a graphics programmer

- And a paired assignment with someone else on the module that should be an extension of the individual demo with intractable objects that uses more advanced rendering techniques.

The report is coming along nicely and with the deadline in week 3. It’s easy to write as a there is more than enough material online thanks to the internet providing the perfect platform for people to ague about everything (Graphics API very much included in this).

The Solo Demo is something that I have wanted to work on for a while. The reason that I got into programming in the first place was to make games, and making a 3D environment that does as many fancy things as possible is exactly what I need to get there. I have already finished an introductory book to DirectX11 and will start on Frank Luna’s Highly recommended DirectX10 book soon as it seems to have a lot more practical techniques in it. I would like to use the DirectX11 version of the book but I don’t have hardware that supports it .

For the paired project we must give a presentation in the last week of term showing off what we have made. I have already teamed up with someone on the course named Elliot, we get on quite well and he seems like a motivated individual so I am looking forward to working closely with him to make something great in a few weeks time.

Application Development

The grade for Application Development is made up as follows:

40%  - Essay

30% – Web Application

30% – Windows 8 Application

Essay

In the module handbook (the details of the Essay have not been given yet) We are to write a research paper about the core concepts, issues and technologies involved in developing and deploying a variety of applications.

Okay, this sounds like it is useful stuff, but we are tasked with writing it first, before we have developed and deployed anything. Surely we should write this at the end when we have had to look into these subject areas when developing and deploying our two applications. The other thing that is deeply wrong about this is that more marks are awarded (and therefor must be more important) for being able to write a paper on deploying application than actually being able to build and deploy an application!

I can not wait to leave academia.

Web Application

For a meager 30% of this modules grade we will have the honor of actually getting to do some programming. We will be using some pretty new tools, we get to use WebMatrix2 and the Azure platform. These are two pretty cool things (but it must not be that important to be able to use a globally salable platform as less than a third of the mark is given for being able to do so).

We’ve not been told much about this project yet, other than we will be using Azure and using some PHP. I’ve done a little PHP before and really enjoyed it so I’m looking forward to it. I’ve checked out Azure a bit as well and it looks like we’ve been given a lot of stuff to tinker around with. We get something along the lines of 2 virtual machines, “Mobile Services”, a few websites, SQL databases and things. Looks like I could make something pretty cool with these tools .

Windows 8 Store App

We have been told even less about this assignment  pretty much the only thing that has been said is that we can make a game if we want.

I’ve got Windows 8 on my laptop and computer and it seems pretty nice, but I never use any of the Store Application on it. It could be a cool thing to develop on but I’ll have too see.

As I write this in its current state Falling Spikes is in an early alpha state as it’s only had a couple of days work done on it in the run up to Silicon Milkroundabout so please forgive the rough edges.

Stay in the square for points!

The objective of the game is to stay alive and get as many points as possible. The player must use the phones accelerometer to move a ball around the screen and dodge the spikes that fall from the top of the screen. There is a square that moves around the screen that the player must stay inside of to get points.

There are collectibles that fall fro the top of the screen as well, the player much touch these to collect them.

So far I have most of the basic elements in the game but there is much to do. When I have some more free time from my university work I intend to make the game look much more appealing, allow the user to tweet their high score and add a collectible that makes the player invisible and can destroy spikes.

Falling Spikes game play.

Whilst I was at Silicon Milkroundabout I found that almost everyone who played it was confused about at what to do, and that almost never tried to get the bonuses the first time they played. This has made me realise that Falling Spikes definitely needs some kind of tutorial when the game first starts. Ideally this would allow the player to get use to controlling the ball, and show them that they have to touch the bonuses..

Install Falling Spikes on you Android phone now!

y = mx + d

The variables y and x simply refer to the x and y position at any point in the line. The m variable is the slope of the line and d is where the line crosses the y axis. Pretty simple to understand (and convert into code).

First of all we are going to create local variables that represent the x and y of the two points. In this example we are passing in a vector of integers and simply copying the values from them.

Code block

void drawline(Vector2 const* const pt1, Vector2 const* const pt2)
{
	// Create local variables to use
	int p1x = pt1->x;
	int p1y = pt1->y;
	int p2x = pt2->x;
	int p2y = pt2->y;
}

After getting the initial values I create the delta terms for use later. The delta terms is another way of saying the difference between the points.

Finding the Slope.

This is the equation to get the slope (m) of the a line between two points. This is nice and easy to implement in code. Make another two variables called deltaX and deltaY. These will be the difference between the two points.

Code block

// create delta terms
int deltaX = p2x - p1x;
int deltaY = p2y - p1y;
 
float currentY = 0;
float slope = abs( (float)deltaY / (float)deltaX );

Then we also need  to have a temporary variable to track our position on the Y axis. This will have the slope value added to it once for each step we take across the X axis.

Now for the part of the code that actually draws the line. We will be going from the left X position to the right X position. A for loop will be good for this.

Code block

int y = p1y;
 
for(int x = p1x; x <= p2x; ++x)
{   // Plot the line along the x axis
	drawpoint(x, y, '*');
}

Here I am creating a Y variable and assigning it to the first point’s Y value. I am also setting  the loop up to move from the first X position to the second. My drawpoint() function is for drawing in a command prompt, but you will have to use or make your own function for this.

If you run this code you will get  a straight line going from the left-most point to the Y position of right point. So we’re halfway there.

Now we need to make the Y value increase at the rate of the slope we made earlier. This is nice and easy to do.

First we add “slope” to the “currentY” variable and check to see if it is over 0.5. If it is over 0.5, then the Y value is over halfway into the next cell, so we add 1 to the Y and take one from “currentY”. Here is the loop to draw the line now.

Code block

for(int x = p1x; x <= p2x; ++x)
{   // Plot the line along the x axis
	drawpoint(x, y, '*');
 
	currentY += slope;
	if(currentY >= 0.5f)
	{
		y++;
		currentY -= 1.0f;
	}
}

And here is the nice line between the two points.

A Problem.

Great, so that looks like it is working, but there is a problem with it. This implementation only works with the first point being below and to the left of the second line. Hmm that’s not what we want really. Below is a screen shot of the issue. If the first point is to the right of the second then no line is drawn at all.

The code we have now has two issues with it.

1: The line can only slope up.

2: The first point must be on the left.

To fix the first issue we need to detect if the first value is above or below the second. Once we know if the second point is lower than the first we simply have to decrease the Y value rather than increase it. This can be done by adding an integer and an if statement.

This code goes above the delta terms being declared.

Code block

int yIncrease = 1;
 
if(p1y > p2y)
{    //The first point is higher than the second
	yIncrease = -1;
}

And this is the new for loop.

Code block

for(int x = p1x; x <= p2x; ++x)
{   // Plot the line along the x axis
	drawpoint(x, y, '*');
 
	currentY += slope;
	if(currentY >= 0.5f)
	{
		y += yIncrease;
		currentY -= 1.0f;
	}
}

Running the new code produces a downward sloping line.

Now to fix the second issue. The problem of needing the first point on the left.

We don’t need to change the code to work from the second point to the first, we can simply swap the first and second point around.

Here is a function that takes two pointers to integers and swaps them around.

Code block

void swapInt(int * a, int * b)
{
	// Simply swaps the passed in values
	int t = *a;
	*a = *b;
	*b = t;
}

Now we simply look to see if the first point is on the right, and swap them around if it is.

Code block

if(p1x > p2x)
{   // The first point is on the right.
	// Swap the points around.
	swapInt(&p1x, &p2x);
	swapInt(&p1y, &p2y);
}

Here is the finished product!

Optimising.

The Bresenham / Midpoint algorithm was originally devised to draw a line using only integers. This is because in the early years of computing every operation done was very time consuming, and working on integers is much faster than using a floating point number. This is still true today of course. Another change that we will be making to the implementation that will affect the speed of the algorithm is removing any divide operations as they are also slow to execute.

The first change to the current implementation is to change the declaration of the delta terms. They now need to be non-negative numbers, so we need to use the abs() function to ensure this. We also now need to make a new integer variable called “delta”. This is going to replace the “currentY” float variable we were using before.

Code block

// create delta terms
int deltaX = abs(p2x - p1x);	// This is the difference between the start and end points
int deltaY = abs(p2y - p1y);
int delta = (deltaY - deltaX) * 2;

Next we need to make two more integers called incE and incNE (as in “Increase East” and “Increase NorthEast”). They are done like so:

Code block

int incE = deltaY * 2;
int incNE = (deltaY - deltaX) * 2;

Here is the new loop we will be using. The new method now requires an else statement for when the line is closer to moving to the right more than it is to moving up. The only other change is that the drawpoint() call is now at the end of the loop.

Code block

for(int x = p1x; x <= p2x; ++x)
{   // Plot the line along the x axis
	if(delta <= 0)
	{
		delta += incE;
	}
	else
	{
		delta += incNE;
		y += yIncrease;
	}
 
	drawpoint(x, y, '*');
}

Now we have a working Midpoint algorithm that does not use floats and does not divide!

Further Optimisation.

As we are now just using integers we are able to use bitwise operations to do useful things like multiply or divide by 2. So where ever there is a “* 2″ in the code, change it for “>> 1″.

Here is the finished function:

Code block

void drawline(Vector2 const* const pt1, Vector2 const* const pt2)
{
	// Create local variables to use
	int p1x = pt1->x;
	int p1y = pt1->y;
	int p2x = pt2->x;
	int p2y = pt2->y;
	bool slope = false;
 
 	// create delta terms
	int deltaX = abs(p2x - p1x);	// This is the difference between the start and end points
	int deltaY = abs(p2y - p1y);
 
	if(deltaY > deltaX) // Check to see if the first point is on the right.
	{
		// Swap the points around.
		swapInt(&p1x, &p1y);
		swapInt(&p2y, &p2x);
		swapInt(&deltaX, &deltaY);
		slope = true;
	}
 
	if(p1x > p2x)
	{
		swapInt(&p1x, &p2x);
		swapInt(&p1y, &p2y);
	}
 
	int yIncrease = 1;
	if(p1y > p2y)
	{    //The first point is higher than the second
		yIncrease = -1;
	}
 
	int delta = abs(deltaY - deltaX) >> 1;
 
	int incE = deltaY >> 1;
	int incNE = (deltaY - deltaX) >> 1;
 
	int y = p1y;
 
	for(int x = p1x; x <= p2x; ++x)
	{   // Plot the line along the x axis
		if(delta <= 0)
		{
			delta += incE;
		}
		else
		{
			delta += incNE;
			y += yIncrease;
		}
		if(slope)
			drawpoint(y, x, '*');
		else
			drawpoint(x, y, '*');
	}
}

The first thing that I am going to write about is a small post about drawing a line between two points. It is a small task that I have been given at University but I have seen it as an ideal starting point for the re-boot of my blog.

I am also going to change the WordPress theme as well, it’s been the same for about 3 years and looks really dull.

So a bit of change all round and a bit extra blogging from me.

I started off in flash learning the basics and getting used to things like Event Handlers. I’ve found the language laid out well and quite nice to work with so far.

I’ve started making a few basic physics simulations using flash. I’ll put a few examples below.

Collisions with mass

When a large ball and a small one collide, the smaller one will bounce off much quicker than the large. Press enter until you get a tiny ball and you’ll see how you can knock it flying easily with a larger one.

Full Screen

Springs

Another thing that I looked into was the use of springs. I can see how these can be extremely effective and can be used in a lot of different areas of games. For now I’ve just made this simple collection of springs that only activate when close to each other. I believe this type of thing is known as a Node Garden.

Full Screen

I’ll most lightly be using this pretty soon in a Tower Defence game that I plan on making in the next couple of days.

I have changed the colouring scheme so that the set looks more interesting as you look around it. Here’s a video showing the movement and the changing colours.

With the added navigation you can see the infinite detail that there is in the Mandelbrot Set. The new colour scheme is relative to the number of iterations so the deeper you zoom the more the colours change.

Another change that I have made is that it uses OpenML to thread the main loop that generates the set. This has given it a performance boost of about 50%. This is much needed for how performance intensive it is to generate the set at a high iterations. Here’s a zoom to the depth that a double precision float is accurate to.

You can see from the video the FPS is still very low but still just about usable. My next aim is to have this running in OpenGL. Using the power of a graphics will give it a significant performance boost.

I was inspired to start this project when watching a program about the creator of Pixar when he first programmed a simple yet effective solution to creating realistic looking mountains back in the 80′s.

Mandelbrot Set.

The Mandelbrot Set has a few interesting properties, the most interesting of all being that its edge is infinite. This means that there is an infinite amount of different patterns hidden in the image above. By zooming in to a small portion of the set you can see how much amazing detail there is.

Here is a portion of the set zoomed in, you can see what I mean by infinite detail.

This image took a fairly long time to render (by today’s impatient standards at least), maybe about 5 minutes. But this is using the SetPixel() function in GDI+. This is a very inefeshent way for drawing pixels to the screen and is soaking up all of the time. You can see in the video below how long it takes using SetPixel. The rendering in this video is rendering at a lower level of detail so the bands in between each layer can be seen.

At  the point of writing this I have not long implemented using the LockBits() to change the individual pixels of a bitmap then draw the whole image to the screen. This is far more efficient and cuts the render time down buy quite a lot as you can see in the next video.

I have now added movement to the program allowing to user to scroll around at a set level of magnification and at a low detail. Then when needed the user can right-click to render with a high level of detail. This is pretty cool and works well.

The next thing that I want to do is improve the speed that it renders again. I am going the long way around to get the gradient effect. As you can see in each video, the whole image has to be generated many times to create the end result. The colour of the pixel is determined by the number of iterations it has taken to check to see if that pixel is part of the Mandelbrot set. It is a simple case of rearranging the way the program is set out to get this number with out having to generate the whole image with different levels of detail and combining them together.

There is a problem when playing a game full-screen however, the game will minimise when it looses focus. This makes the game take a while to maximise again when it regains focus, an absolute pain and making having another monitor useless.

Most games offer an option to run in a window. This stops the focus issue as the game will continue to run. The problem with this is that if you are to set the games resolution to the full size of the screen the border will push the bottom of the window off the monitor.

A few source engine games have the option of Full-Screen No Border. This is exactly the solution to the issue.

If you are playing a game that does not offer this mode there is a solution! It is called ShiftWindow and can force the position of a window to be above the top of a monitor.

ShiftWindow

You can download ShiftWindow from its website here.

Once you have downloaded and installed it you may need to run it as an Administrator.

When it is open click the first “Grab” button and get the window title of your game.

Next in the “Shift to” section of the window select Coordinates radio button and the “Set size client area” check box.

Click the Trigger it button and you’re done!

This should automatically set the window to be full-screen with the borders hidden off-screen.  You can now tab in and out like a windowed game, but have the joys of full-screen!

I hope that this tutorial was helpful, any questions leave a comment below.

Dan

My sister has a very slow laptop running Windows XP. It had good 1GB memory with a Intel Atom 1.6Ghz  and for a hard drive it has an old 16GB SSD.

My first solution to try to fix the problem was to just do a fresh install of XP, this took hours just to install because of the slow SSD but once it was in there it was still crushingly slow.

So onto Chrome OS. All my sister really uses her laptop for is Facebook music and chatting to friends. This is exactly what Chrome OS is designed for – Light internet applications.

To begin I downloaded the Chrome OS Flow from this website: http://chromeos.hexxeh.net/ In torrent form. Unfortunately is wasn’t very well seeded so it took quite a while but once I for it I put it onto a memory stick using this Imaging Program.

Click to go to website.

Once I booted from the memory stick on the laptop I already had a version of Chrome OS working. Things seemed to work fine from the memory stick. To install to the hard drive I opened up a terminal by pressing Ctr+alt+T and typed “Install”.

Boom. Installed to the local Hard drive.

It boots nice and fast. You can be on browsing the web in well under a minute even on this low spec hardware. The interface is all tabbed based even if you are opening a new “window”. The windows slides in from the right of the screen over the top of the previous. The interface is nicely polished and works well. You sign into the laptop as if you were signing into a gmail account and then you seem to be automatically signed into any Google services.

There is the option to sign into the OS using a guest account. This is just the same but it runs in  incognito mode so nothing is retained on the laptop once you sign out or turn it off.

Chrome OS isn’t much more than a web browser but it is nice and light even running on this 3 year old netbook I found myself browsing the web with no slowdown at all. They have done a really good with Chrome OS and it has breathed new life into this old machine.