Last Ray of Hope

I just found out that by adding this HTML tag to the HTML of my post…

<!–nextpage–>

…that I can split it up into multiple pages on a single post. This will clean up a lot of my text, I’ll have to go through the backlog of stuff I’ve posted that is long.

The old one wasn’t really working well for alignment of images and text, and was causing problems with the syntax highlighter (which still isn’t perfect). I may justh have to write my own at some point, or find a better plugin.

This one feels like there is more space, rather than having cramped text, plus I love the little date things on the side. When trying to switch the cheaply made background to replace with one of my own it failed, but to my surprise this theme works best without a background image.

Spending my last three days of toil this week, thus giving me a five day weekend, it would be nine if you count Easter but since I went into work yesterday, I decided to add another entry into my guide for using OpenGL with Cocoa. During the process of this, I discovered XCode had source management built into it, so I decided to investigate further, and finally got my project synchronized with a server.

So I decided to write this guide to using XCode with SVN. The SVN provider I’m using for this is CVSDude, they’re cheap and very reliable. But any service provider should work with this guide.

First of all, log into CVSDude, goto the “Settings” menu at the top, then “Modules” on the menu to the right, and then click “Add“. Give a name to your new module, I chose ‘CocoaGL’, which is the name of the project used in the other guides, and click “Add new“.

You now will have a new repository, the address of which will be something like “https://<username>-svn.cvsdude.com/<module>”. If you are unsure or you are having problems, see the “Welcome” page when logged into your CVSDude account.

Now open up a copy of XCode. Before opening a project, goto the “SCM” menu and select “Configure SCM Repositories…“.

Click the “+” button to add a new repository to the list, now give it a name, yet again I chose ‘CocoaGL’, and instead of “CVS” chose “Subversion” from the dropdown list. Now click “OK“.

The repository locally now needs to be configured, within the “URL” box, enter the url to your source, in my case it was “https://kaluriel-svn.cvsdude.com/CocoaGL“.

This will automagically fill out most of the other text boxes, apart from username and password. If the path is okay, you should get a red circle with an error something like “Error: 170001 (Authorization failed) Description:”.

Within the username field box enter your account username, and within the password field box, your password. After a second the red circle should change to green with the text “Authenticated” to let you know it has successfully logged in. Click “OK” to close the window and return the main XCode environment.

Another part to my series of guides for programming in OpenGL with Cocoa. Yesterday I showed you how to actively render in OpenGL with Cocoa: Part 2.

This entry however will show you how to make the OpenGL view the first responder to ‘messages’, so that you can get key input and control turning of the triangle. All of the new functions with the exception of “keyAction” are overloaded and so a part of the Cocoa view system.

The new attribute “m_keys” will be used for storing the status of the key being pressed, true if it is pressed, false if it isn’t.

Now when the application is started, we need to reset the values for “m_keys” to false so that we don’t have uninitialized data. We can do this within the functions “awakeFromNib” or “initWithCoder” but I have chose to do it within “initWithFrame“.

With that done we need to implement our new functions. For “acceptsFirstResponder“, “becomeFirstResponder” and “resignFirstResponder” we return “YES” so that the OpenGL view class we are using gets the messages first instead of the main window.

For “keyDown” and “keyUp” we check to see if there is any input and then forward the information onto one of our own classes, “keyAction” with a value which specifies if the key is pressed or not. This is they set to the Boolean array a the appropriate index.

We could just use the “keyAction” function to control the triangle, however we would be limited in update cycles depending on the repeat rate of messages during a key press.

Now during the “drawRect” function, we check the status of key presses within the Boolean array. If the key ‘A’ is pressed, we rotate the triangle left by one degree per frame. However if ‘D’ is pressed, it will rotate the triangle right by one degree per frame. And if neither are pressed, nothing will happen.

As before we are not using glLoadIdentity() so the resultant matrix from the last frame is being modified, not a new one which we would have to store and increment a rotational value for.

With the new changes, build and run the application, and pressed ‘A’ and ‘D’ to watch the triangle rotate differently. In the previous guide it rotated constantly, however now it requires key input of specific keys to rotate it, and you have control over the direction of rotation.

Thats all for OpenGL with Cocoa for the moment. Still working out some of the bugs in my own applications as I convert them from GLUT, so hopefully the next guide will show you how to switched between window and fullscreen modes.

Download Source: CocoaGL Source (Part 3)

Following on from yesterdays entry, OpenGL with Cocoa: Part 1, this entry will expand upon that.

First of all, we need to add some new functions to our OpenGL view class, as well as a few attributes. “m_rectView” will be used to store the current window rectangle, whilst “m_timer” will be used for updating the window for redraw.

The “initWithFrame” function is called before the OpenGL context is setup, it is used to set the pixel format conditions for the context. The other functions are called by our own code.

I’ve image to the right shows the source for the new functions. Within the “initWithFrame” you can see we’re requesting a format with a double buffer, accelerated hardware, 32 bit colour buffer, with 24 bit depth buffer and an 8 bit stencil buffer. We then call the same function within the NSOpenGLView class we’re inheriting off.

The “setupAnimationTimerWithInterval” function sets up a timer object that fires “timerUpdate” at a specified interval. That function calls “setNeedsDisplay” to make the window redraw. The framerate can be killed if we draw in both the “timerUpdate” function and the “drawRect” function.

Within the “prepareOpenGL” function, we call the “setupAnimationTimerWithInterval“. Now within the “drawRect” function, we call “resizeGL” which if the rectangle is different to a previously stored one, we make a call to glViewport() to update the destination bounds.

We also change the glFlush() call to a call to a call to “flushBuffer” call from the current OpenGL context, this is because we are now rendering with a double buffer instead of a single buffer.

You may have also noticed there is a call to glRotated(), since we don’t call glLoadIdentity() every frame, this will rotate our rectangle, showing that our application is running and updating consistently.

If all goes well, you should have an output like the one in the right image (well at some point since it is rotating).

Well that is all for using OpenGL with Cocoa for the moment, the next part will cover basic keyboard input.

Download Source: CocoaGL Source (Part 2)

In a previous entry I said I would show how to setup an OpenGL application using Cocoa. This guide will be slightly more thorough than the one written on the Apple Developer Site. The version of XCode I’m using is 3.1.3, but I’ve included lots of pictures, which will hopefully work around problems with changes in versions.

First off, this is an extremely basic program, single buffer which is only redrawn when the window’s rectangle is dirty. To start off, open up a copy of XCode and create a new “Cocoa Application” and give it a name. I named mine “CocoaGL“.

Once created you should have something that looks kinda like the image on the right.

Now you have setup a basic Cocoa application, if you click “Build and Go” you will have a Cocoa window being displayed, however if you click the Red button to close the window, the debugger is still running because the application is still active.

But we’ll get around to fixing that later. Now for using OpenGL, we’ll need the OpenGL framework (a framework is a special folder that contains headers, resources, libraries, etc for a particular third party library).

To add a framework to an application, right click on any folder in the project (I use an already created one), select “Add” and then “Existing Frameworks…“. Now to find the OpenGL framework, navigate to “/System/Library/Frameworks/“. Now search through the folder and select “OpenGL.framework“, and select “Add“, and “Add” again.

With the OpenGL library now linked to the application, we need an Objective-C class for our OpenGL window to be associated with. To do this, we’ll need to inherit off NSView or NSOpenGLView (with NSView we’ll need setup OpenGL ourselves, so for now we’ll use NSOpenGLView). Right click on a folder in the project again, but this time select “Add” and then “New File…“.

Select “Objective-C class” from the list. You can also “Objective-C NSView subclass“, which will create a class with the functions “initWithFrame” and “drawRect“, as well as inheriting off NSView. But I’ll be providing the code for the class so any Objective-C class will be fine.

Upon clicking “Next” you’ll be presented with a screen similar to the one on the left. Choose a filename, for my code I used the name “OpenGLView” (this will also determine the class name. Make sure a header is created with this source file, one nice thing about XCode compared to Visual Studio is that it gives you this option.

Click “Finish” and your source and header files will be created for you, opening the header for you to view straight away. I’ve shown what is given by default, this can be used for normal window associated stuff, but it lacks an OpenGL context as well as setting up the pixel format information, that will allow us to use OpenGL.

Change the inherited class to NSOpenGLView (this does all the default stuff for us). Now add two addition functions, “prepareOpenGL” and “drawRect“, check the header for NSOpenGLView or the Cocoa documentation for more information. The image to the left shows what parameters and return value the functions use.

Now open the source file (Objective-C uses the extension .m, while Objective-C++ uses .mm). Within the “prepareOpenGL” function, this is where we setup our OpenGL context, I’ve set the clear color and I’ve set the swap interval to be synchronized with the vertical refresh (vblSynch value needs to be set to 1, 0 is as immediate).

And the “drawRect” function is used for, as you may have guessed, redrawing our screen. For now I’ve added code to clear the screen, draw a yellow triangle and flush the buffer (glFlush is used for a single buffer, rather than double).

With that done we need to link a window to the class we’ve just created. So find the XIB file within the project, and double-click it to open it up Interface Builder.

Within the Library window of Interface Builder, do a search for “Custom View“, then drag and drop the found object onto the window, and resize it if you want to be the same size as the window. There is also an “OpenGL View” object that gives you more control over the default settings, however I find it more restrictive to use.

Now open the “Size Inspector” window for the object we’ve just created, if it isn’t already open, goto the “Tools” menu and select “Size Inspector“. Click all arrows within “Autosizing” so that the object will automatically resize when the parent window is resized. See the image to the left for more information.

Now open up the “Identity Inspector“, if it isn’t open already you can access it from the “Tools” menu as well. Within the “Class Identity” section, set the “Class” to the name of the OpenGL view class we created, the auto-complete will help you find it. Once this is done, goto the “File” menu and select “Build and Go in XCode” – this will exit Interface Builder, build the project and then start it running.

If all has gone well, you’ll see a window like the one on the left image. However, if you try to resize it, it will remain in the same place (this is because we didn’t change the viewport size when the window is resized, this will be covered in the next part of this guide to using OpenGL in Cocoa).

One other thing you’ll notice is that if you close the window the application will still be running as mentioned earlier.

To fix this, we need to setup an object to handle delegations from the application, one of which is whether the application should end if a window is closed. So as before when we created our “OpenGLView” class, create a new class, I’ve called mine “AppDelegate“.

When it is created, add the function “applicationShouldTerminateAfterLastWindowClosed“.

Now add the function to the source file as well, returning “YES” so that the application will end when a window is closed.

Now find the XIB file again and double-click to open it up with Interface Builder again.

Now search for “Object“, and drag and drop the NSObject (the blue cube on its own, not the blue cube within the green circle) into the XIB window. Open up the “Identity Inspector” for the Object just created and then set the Class to the application delegate class we just created.

Now we just need to link the application delegate to this newly created Object associated with our delegate class. To do this, select “Application” from the XIB window, then open the “Connections Inspector“, available from the “Tools” menu.

Now drag from the “delegate” selection circle, to the delegate object. If done successfully, “delegate” will have a shaded box around it and the name of your delegate class you created on the right.

Go to the “File” menu and select “Build and Go in XCode“, you should now have a basic OpenGL application made in Cocoa, with a window that will shutdown the application if the window is closed.

The next guide will cover rendering with a double buffer, handling resizing, and a render loop of 60 frames per second.

Download Source: CocoaGL Source (Part 1)

I’ve been converting my Cg shaders I wrote for my AGT work in university into GLSL, however I came by an annoying problem, Cg uses a function that doesn’t exist in GLSL, but does exist in HLSL. I eventually found documentation on what it does and so looked up the GLSL equivilant. The Cg version shown below…

float3 outValue = saturate( inValue );

Becomes the following when converted to GLSL…

vec3 outValue = clamp( inValue, 0.0, 1.0 );

Thought this might be useful for others who might be having the same problem.

After completing Fallout 3, one of my friends at the office lent me their copy of Resident Evil 5 to play over the 4-day weekend. I started playing a little on Thursday, and watched Tales from the Crypt and caught up on House M.D. Friday I played through all day, apart from the time spent trying to get my iPhone working again, and then finally completed it this afternoon.

I have to say I really enjoyed it, I haven’t played a Resident Evil all the way through since the second one, apart from a little time I spent on four. As usual with shooters on the XBox360, it took me a little while to get use to targetting with an analogue stick. One thing that did annoy me, was that I couldn’t move and aim (my favourite thing to do since Dead Space made to fear going around a corner).

Some of the new bosses were really creative, ranging from giving you a flamethrower than you need refuel, to firing a missile at the boss only for them to catch it then you shoot it to make it explode in their face.

Some of the enemies are annoying to defeat, the chainsaw guy at first killed me many times before I figured a strategy to take him one. And later in the game, I found out I could shoot different objects such as transformers to electrocute enemies.

The only thing that does annoy me about this game, are people thinking it is racist, I was reading about it on another persons blog, who was arguing against another persons blog.

http://www.blacklooks.org/2007/07/resident_evil_5.html

To quote them incase they decide to retract their blog entry

The new Resident Evil video game depicts a white man in what appears to be Africa killing Black people. The Black people are supposed to be zombies and the white man’s job is to destroy them and save humanity. “I have a job to do and I’m gonna see it through.”

This is problematic on so many levels, including the depiction of Black people as inhuman savages, the killing of Black people by a white man in military clothing, and the fact that this video game is marketed to children and young adults. Start them young… fearing, hating, and destroying Black people.

First of all, they aren’t suppose to be zombies, they are zombies, and the fact these zombies are trying to kill you doesn’t make the people they were originally inhuman savages. The fact it is a white person doing this is because Chris Redfield is white in the previous games, changing his appearance breaks the game history. And to top it all off, it was made by Asian developers.

Apart from that annoyance, I really enjoyed the game, and I hope for more DLC. I might even buy my own copy so I can do the multiplayer thing, actually that is another thing I wouldn’t mind when playing it, someone to Co-Op it with, I died a few times since Sheva was too busy waiting for me to do something (i.e. holding an enemy, waiting for me to shoot an enemy, etc).

Original blog I found this link from:

http://theblacksentinel.wordpress.com/2007/08/04/resident-evil-5-outbreaks-the-racism/

With the release of iPhone 3.0 Beta 2, which automatically unlocks tethering as well as fixes a few other bugs with Beta 1 that were annoying me, I finally got around to upgrading.

However, during the process of the upgrade (I selected Update instead of Restore this may have been what caused it), an error occurred. Fearing I may have just bricked my iPhone with a firmware changed, I quickly ran Restore, only for it to fail with an Error 1611, or maybe it was 1602 or 1604.

Searching the interwebs, I found various people who had the same problem with earlier version of the iPhone firmware, and one recommended putting the iPhone into DFU mode… BIG MISTAKE! It turns out that MacOSX doesn’t recognise an iPhone in DFU mode, treating it like an iPod and giving Error 2001 messages. But not only that, but I was stuck in DFU mode (which btw is a black screen with no way of knowing if it is turned on or not).

The only solution at the time I could find around this was a piece of 32bit Windows software, which wouldn’t work with my 64bit OS. Luckily I came by some instructions the next day, which said to exit DFU mode, all you have to do is hold power and home for 10 seconds. I don’t know if it was this however, since I think my iPhone had run out of power, I might have just been turning it back on.

To fix the original problem, all I did was delete the ipsw files in “/<user>/Library/iTunes/Device Support” directories. Restore didn’t work until I manually Restore using Firmware 3.0 Beta 2 (probably something gets changes which is why you can’t downgrade through normal means).

For a while now I’ve been playing through Fallout 3, jumping between the main storyline and sidequests every so often. When I first started playing, I didn’t enjoy it, the game was slow for progression, and not too well explained on how things work – one example of this is moving objects, I completely forgot that I could move objects with the right analogue stick.

But as the game progressed, things got interesting, missions started to be worth the effort put in, and money was no longer a problem, and once I finally reached Rivet City, neither was ammo. Combine that with Fort Independence for turning in Power Armor and Plasma/Laser rifles for 556mm ammo, and I was practically invincible.

This was all ruined when finally I reached the final mission, I had Liberty Prime on my side, and I was on my way to take back the Water Purifier, but Liberty Prime did all the work, and any mutants that were left over were killed by Fawkes and his Laser Gatling Gun. Not even one Super Mutant Behemoth.

I wish there was a way to change perks and stats again, later in the game after getting an understanding of how the system works, I realised a lot of the choices I made at the beginning were the wrong ones since they were badly explained what they do. I could play it through again and choose perks and skills more wisely, rather than waiting them on things that would be useless later on.

There is hope on the horizon though, apparently Broken Steel, the next DLC, will not only raise the level cap, but change the awful ending. I will probably just wait til then and continue, or maybe restart my character and make different choices.