Those who know me know I used to do quite abit of development in c# using Microsoft’s XNA platform.

Well I like to check back in every now and then with some of the big players in the community to see what’s going on.

One of those players is Catalin Zima, who is famous for producing many great shader and effect samples.

One of Catalin’s reccent project particularly caught my eye however as I had tried to tackle the same problem several years ago when I was in my final year of university. That is, Dynamic 2D Shadows Calculated on the GPU (http://mikecann.co.uk/university-projects/shadowshader-in-rendermonkey/)

Catalin’s approach to the problem is far more elegant that my brute force iterative approach. He uses a clever technique of distorting the desired casting image about the light in such a way as not to require iterative pixel lookups.

If you are interested in the more details in the technique I encourage you to check it out over on Catalin’s blog: http://www.catalinzima.com/2010/07/my-technique-for-the-shader-based-dynamic-2d-shadows/

A while back, I had an idea for a very simple application that would sit in your taskbar and give you at-a-glance performance info about your system, similar to iStat Pro for OSX. This weekend I finally had time to clean up the code up for release.

The problem is that while looking for a couple of images for the app I happened to stumble across Taskbar Meters, which is pretty much the exact same idea I had. Looks like he has made a better job out of it that me too

Ah well, I have decided to release my version of the app nonetheless:

You can open the app multiple times and set each one to monitor a different value:

I have also decided to post the source up on google code: http://code.google.com/p/win7-taskbar-mon/

Anyways you can grab version 0.1 here: http://win7-taskbar-mon.googlecode.com/files/Windows7_Taskbar_Monitor_v0.1.zip

For a while now (alot longer than I had hoped for) I have been working on a project that falls outside the realms of my usual kind of games-related projects. Im not ready do describe exactly what it is yet but im excited about it.

For months I have been struggling with the techinal challenges the project has entailed and I have dabbled with many new and highly diverse technologies including JavaFX (Java), Qt (C++) and Mono (C#).  I have been looking for a cross-platform technology that will get the job done that I need and doing it in an elegant manner.

I thought I had found it with a combination of JavaFX and straight Java using the PureMVC framework. I however was plagued with problems throughout with Bonjour, jGroups, JmDNS, JNI and JNA.

So after months of work, hardship and struggles I read a very interesting article on the up-and-coming Adobe AIR 2.0  that was opened for beta in December. With 2.0 Adobe are bringing NativeProcess  to Air. What this means is that you can you can execute native code (.dlls, .so, .jar etc) from Air. To me this was bloody brilliant as I had been playing with Air reccently and my day-job heavily involves Flex and I simply love the power and beauty of Flex.

So what this meant to me was that I could write the bulk of my project including its interface in my much preferred Adobe Flex (Air) and then use Native Process to communicate with a small kernel of Java that would do all the dirty work that Air itself cant do.

So after a little playing with Flerry for Air->Java bridge I started to think about the structure of the code and the framework I would use. For my initial few runs at this project I had been using the Java version of PureMVC. I really like some aspects of PureMVC but I think its can be so overly cumbersome in some circumstances (ill write another post on this in the future I think). So instead I looked at the alternatives.

I have been using Mate alot recently at work and on my own mini-project the Audio Book Organiser. However as this project is partly for my own learning and personal growth I decided to look at what else there was out there. From the videos by Jessie Warden I had heard about Robot Legs. Apparently this framework has been around for a while, but it was the first I had heard of it. Taking at look at it I immediately became very excited as it looks like it offers all the things that make PureMVC great but without the extra coding-baggage that goes with it.

To add to my interest it appears another very interesting, very new action-script technology has been introduced into Robot Legs called Signals by Robert Penner. Signals is an alternative to the standard events dispatching method found throughout flash (more on this in another post).

So why have I called this post “the bleeding edge?”. Well Adobe Air 2.0 is still in beta and has only been for a month or so. Its so new that some parts still havent been documented atall and the only way to find out how they work is to post a msg to the devs on the forums. Signals is also new and its integration into Robot Legs is very new indeed (last coupple of weeks). So at the moment I feel as if im at the forefront of some very new, very exciting technology, a stark contrast to my fiddlings with the ancient Java.

I realise this post is very text and tech-heavy but I needed to post about it before I forgot all the pain I have gone through with this project to get where I am at the moment. Future posts ill be delving a little deeper into some of my experiments with these new technologies

Screenshot

DLL
http://www.mikecann.co.uk/Files/GoToDefinition.dll

Source
http://www.mikecann.co.uk/Files/GoToDefinition_source.zip

Post
http://www.flashdevelop.org/community/viewtopic.php?f=4&t=4722

EDIT:
It appears that the same functionality is built as standard into FD with the use of the F4 key. Oh well, you can still use this as a shortcut

Its an excellent upgrade and brings some extra features that were lacking in my very basic version.

Copy / Paste of his update:

Liked the plugin so much I decided to add a few features! Posting here with Mike’s permission.

Screenshot

Updates
Added 4 plugin setting options:

Highlight Color (Choose a color for the highlight)
Highlight Whole Words (Choose whether to highlight whole words only or include partial text)
Match Case (Choose whether to match the case of the selection or not)
Add Line Marker (Display a line marker next to highlighted text)

No longer highlights white-space characters

Installation
+ Open FlashDevelop, Click Tools -> Application Files
+ Copy the DLL to the “Plugins” directory
+ Restart FlashDevelop

DLL
http://gonegothic.com/files/flashdevelo … ection.dll

Source
http://gonegothic.com/files/flashdevelo … ection.zip

After a few evenings work however I decided that this project was going to take up a bit too much of my time, especially when I had so much other work to do. So I have decided to release what I have done and let other take it and develop it if they wish.

You login using a twitter account:

Once logged in you are presented with the main interface, plugins are loaded automatically from the directory and displayed as tabs. The reason for doing them as plugins is to allow users to pick and choose what functionality they want their twittbot to have. Also it allows for easy upgrading to newer plugin versions.

Hangman was the primary idea for this project and is implemented as a simple plugin that consists of 3 simple commands:

I have built a simple polling timer for checking new messages from Twitter:

The interface uses docking panels provided by the .NET DockPanel Suite. Docking is demonstrated below with the log window:

The next shot shows me sending a direct message to the “twittgames” account from my “mikeysee” account:

After refreshing, the Hangman plugin then shows the active game states:

Then you play the game by making guesses:

A

And the plugin responds to your guesses:

It is far from complete but as a proof of concept I think it demonstrates the idea. There are many things that could be improved and/or worked upon, such as:

• Implement async calls rather than halting the thread when making a call
• Completing the Auto-follow plugin
• Implementing a database to log previously handled messages
• Enable back-messaging so you can search for previous messages and handle them
• Implement an interface for loading/unloading plugins

For the technology side of things, its was developed in C# .NET 3.5 using the excellent TweetSharp library for interfacing with Twitter. Docking panel functionality is provided by DockPanel Suite.

You can grab the binary for this here: TwitterBot.zip

Source code is available on request. Email: mike.cann@gmail.com

http://www.mikecann.co.uk/?p=163
httpvh://www.youtube.com/watch?v=vxrg1YavBIg

http://www.mikecann.co.uk/?p=169

httpvh://www.youtube.com/watch?v=3wdIiCCAb9U

I have another reason for these old re-posts, something a little more flash orientated.. Stay tuned for more info

One project I have been working on for a while (in my spare time at work and in the evenings at home) is a new version of PlaceEd. PlaceEd is a small app used by people at work who need to design levels with objects and paths in them.

The reason for making this new version was because the original was starting to show its age and after several modifications to customise it to certain projects it has become unreliable. A second version (PlaceEd2) was half coded by one of the other employees at rockpool though they ran out of time and didn’t complete it.

So that’s where I come in, and I wrote from scratch a new app and called it PlaceEd 3 (even though there wasn’t really a fully released version of PlaceEd 2).

PlaceEd3 lets the user create a new project. This project can have levels added to it. Each level can have a certain number of layers. Layers can be either one large image or a tileset and tileset data. The user can then create objects and give them variables that can either be static (global to all objects of that type) or they can be local which means each object has its own value for that variable. Objects can then be placed on the level and moved and dragged about. Paths can also be placed on the level, this is useful for games that need to script specific movement sequences.

Once a level has been designed it can then be exported as a single binary file that is easily compressed and a java source file that gives a demonstration of how to load the binary data file.

The whole app is written in C# using WeifenLuo docking panels. For the rendering of the level I have integrated an XNA 2.0 panel for speed it gives.

When i got home i tested out my theroy and the results can be seen below. Its pretty obvious that its not perfect but as i say it was just me messing.

Oh BTW grant kot has been working on his polluted planet some more, and its starting to look quite impressive now its over in XNA: link1, link2

I started this time from some work done by the CUDA team over at NVidia. As im running windows Vista i couldnt get CUDA to work so i read through the source and adapted it to my needs.

As you can see from the video below its better than my last attempt but still not perfect, it also still runs on  the CPU on a single core and has had no optomisations applied to it.

Hopefully tho i can build on this to make it better.