On a recent project for work, we needed to create a away to transition between different environments in a Silverlight site. Along with that, there was a vignette effect that would be applied in each environment to add a little something to each one. To accomplish this, we decided the best way to go would be using a pixel shader to create the clean transition and an effect that won't bog down the site. Since I'm still not completely familiar with the HLSL that goes into creating pixel shaders, I found this blog post by René Schulte that used a similar effect to make a very cool old movie style that could be applied to a media element. In other words, he did all the hard work and I was able to pull from his example to help create the effect we used :).

First things first, here is a live demo of the effect in action:

<iframe src="http://www.evanjohnston.com/demos/vignettetransition/" width="600px" height="375px" frameborder="0"></iframe>

*Note: Images used here are from digital blasphemy who creates some very cool desktop wallpapers that you should definitely check out.

Shade the Pixels

The first part of creating the effect that we will in turn use to create our transition is the effect itself which looks something like this:

sampler2D input : register(s0);

/// <summary>Change the radius of the effect</summary>
/// <minValue>0</minValue>
/// <maxValue>10</maxValue>
/// <defaultValue>0</defaultValue>
float VignetteRadius : register(C0);

float4 main(float2 uv : TEXCOORD) : COLOR 
{ 
    float4 color = tex2D( input , uv.xy); 

    // Calc distance to center
    float2 dist = 0.5 - uv;
    
    // Vignette effect
    color.rgb *= (0.4 + (-VignetteRadius * 0.04) - dot(dist, dist)) * 2.8;

    return color; 
}

The first thing we do is to get the distance we are from the center, then we take our Vignette Radius variable that we defined and do a little math. The inverse of the vignette radius is what will allow us to create the transition animation as I'll show below.

Create the Animation

Once this effect was created and tested in Shazzam, which I think is the best tool out there for creating pixel shader effects for WPF and Silverlight, we will use the class generated to add our effect to the images and add in the animation. To do this, we will import the namespace into our XAML and then apply the effect:

<!-- add namespace -->
xmlns:shaders="clr-namespace:VignetteTransition.Shaders"

<!-- apply effect -->
<Image.Effect>
    <shaders:VignetteEffect VignetteRadius="0" />
</Image.Effect>

Now that we have the effect added to the image, we just need to create a simple double animation to change the radius of our effect and show/hide the current image:

<DoubleAnimationUsingKeyFrames Storyboard.TargetName="image" Storyboard.TargetProperty="(UIElement.Effect).(VignetteEffect.VignetteRadius)">
    <SplineDoubleKeyFrame KeyTime="00:00:00" Value="0" />
    <SplineDoubleKeyFrame KeyTime="00:00:01" Value="10" />
</DoubleAnimationUsingKeyFrames>

and voila! We have a simple but clean transition animation that can be used. The demo above uses two images and just swaps their visibility and then reverses the effect to show how it can be used between two different environments. To see the full source of the demo, the code is available for download below. Happy coding!

VignetteTransition.zip (13.62 mb)

In my last couple posts, I went over logging a user into Facebook via Facebook Connect, getting that user's information and then grabbing some of the profile pictures for their friends. All of this was quite simple and brought to you by the Silverlight Facebook SDK. This post will grow more on the first post and will show you how to publish to the user's Wall and News Feed as well as update their status.

Tell the World

One of the key things that any Facebook application should do is publish messages to the user's stream on their Wall and News Feed. This helps spread the word that people are actually using your application as well as showing scores and updates for that user and giving some insight into why people should use your app. The first part of this equation revolves around the privacy settings that Facebook has in place. Since we are going to be doing more than just getting information, we will need the user of our application to grant extended permissions to us.

There are a couple of ways to do this, but the easiest one requires us to just add some javascript. We haven't had to do anything to our javascript files yet, but I assure you this will be quick and painless. In your application, locate the fblogin.js file. This is usually located in the root of your web project, but in my examples has been put in a scripts folder that located at the root of the site. Once you crack that bad boy open, locate the facebook_init method. Inside this method there will be a FB.init method call which is part of the Facebook Javascript Client Library. Update this method as follows:

// original method call
FB.init(appid, "/xd_receiver.htm");

// updated method call
FB.init(appid, "/xd_receiver.htm", {
    permsToRequestOnConnect: "publish_stream"
});

The change we are making is to add in a comma seperated list as a parameter to our FB.init method that tells Facebook what extra permission(s) we want the user to authorize. In this example, we are just passing in publish_stream which will allow us to publish the user's news stream and wall as well as update their status. A complete list of the extra permission that you can request are here. Also, once the user has authorized your application, they won't be asked again unless they remove the setting in their profile.

News Feed

So once the user has given us permission, we use the Facebook.Rest.Api.Stream.PublishAsync method call to publish to the user's stream. When doing this, we have a couple of options. We can go the boring route of just putting up a message, or we can get fancy and add in things like links, images, and videos. The simple call looks something like this:

_facebookApi.Stream.PublishAsync(message, StreamPublishCompleted, null);

where message is just a string that we pass in the for the message the we would like to post. To add in attachments and a littler more detail, some more work is involved:

// create new attachment
attachment a = new attachment();
a.name = "This is a Test";
a.caption = "This is cool";
a.href = "http://www.evanjohnston.com";
a.description = "Here is a description that goes with this post. Here is more content to make this longer.";

// create new attachment media
attachment_media_image i = new attachment_media_image();
i.href = "http://www.evanjohnston.com";
i.src = "http://www.evanjohnston.com/misc/cheerssmaller.jpg";
i.type = attachment_media_type.image;

// create new list of attachment media
List media = new List();
media.Add(i);

// add the media to the attachment
a.media = media;

// this could be the id of a user to post the message to
string targetId = string.Empty;

// create message string
string message = "Testing publishing to the stream from the Silverlight Facebook SDK.";

// make the api call
_facebookApi.Stream.PublishAsync(message, a, new List<action_link>(), targetId, 0, StreamPublishCompleted, null); 

Since there is quite a bit going on here, I'll just defer to the Facebook Wiki on this topic for a more thorough explanation. The gist of what is happening is that we are creating an attachment for the message and then adding an image to this attachment so that there is more to publish than just text.

Status Update

To show another example of what we can do once the user has give our application extended permissions, we will go ahead and update their current status as well. To do this we go with the Facebook.Rest.Api.Status.SetAsync method call. This call is straightforward and looks like this:

_facebookApi.Status.SetAsync(status, SetStatusCompleted, null);

where the status variable is a string that contains the text we want to use. It's just that simple.

Conclusion

So in this post we expanded on our last foray into the Facebook SDK and were able to show what is required to actually publish information to the user's status and news feed. Hope you enjoyed this brief look at the Silverlight Facebook SDK.

Code!

Here is a download of a small demo application that uses the steps that were just discussed. In order to run the application, you will need to set up your own Facebook application. Until next time, Sláinte!

FacebookMemoryPartIII.zip (2.12 mb)

Yesterday, Microsoft announced the new Window Phone 7 Series(WP7S) at the Mobile World Congress in Barcelona. My initial reaction to the thought of another Windows phone was not a good one since I went through the pain of having one of their older versions a couple of year ago in which they tried and failed to run the Windows OS on a phone. It just wasn't pretty.

The New Look

After watching some of the live streamed press conference, I was delighted to see that they had completely revamped the UI for their next foray into the mobile phone. For a good look at what the new phone has to offer, I recommend you read this article on Gizmodo that has a very good overview of everything. Since I bought a Zune HD last year, I was impressed with what Microsoft had done with the UI on that device and was nicely surprised to find it was very different from anything I had seen from them previously. The new WP7S looks to have taken this slick UI and expanded on it to make the experience of using your phone much more enjoyable.

Good 'ol IE

Since this is a Microsoft product, we had to know that they would use Internet Explorer as their web browser. We can only hope that this implementation of it will be comparable to the browsers that run on the Android and iPhone. The up side is that it looks like IE on WP7S will support multitouch out of the box, which is important for any smart phone browser.

The Futurepast

Many of the comments that were coming across on Twitter yesterday appeared to say something to the effect that this new phone has "out Appled Apple" as is discussed in this article on Gizmodo. The new UI is a different take on how a person can interact with their phone to get the information they want.

I think that Microsoft had to do this in order to try and gain their corner of the market share. They are already late to the game, so they needed to use a new take on this interaction in order to get people to think of them as a viable option. This new mode of interaction could be the future, but are people going to take to it with the more app centric model that we are used to from the past and present.

Shoe Phone?

On a somewhat related note, I came across this article talking about another new phone that will be coming out from Puma. The Phone does have some cool features like a solar panel on the back for charging, but there is really going to be a Puma Phone? What's next, a Ferrari Phone?

In my last post, I showed how easy it was to have the user log in to their Facebook account via Facebook Connect using the Facebook SDK for Silverlight and to then retrieve that user's information. This post will take the working parts from Part I and expand on it by showing how to get the user's list of friends and then grabbing the latest profile picture for those friends. I also hope to have a full working version of the game up by early next week that will be available on Facebook. I will post a link here when it's available.

How Popular are You?

So in the last post, we got our logged in user, now let's go find all their Facebook friends. To accomplish this, we will call the Facebook.Rest.Api.Friends.GetAsync method and we will pass in the uid of our user as well as a callback method that will handle the return from the api.

// here is the code for this method call
_facebookApi.Friends.GetAsync((long)_currentUser.uid, GetFriendsCompleted, null);

Once we have the list of friends, we go out and use the Facebook.Rest.Api.Photos.GetAlbumsAsync method to retrieve all of the photo albums for each friend. For this demo, we will just grab the photo albums of the first twenty friends, in case they're really popular. The GetAlbumsAsync methods takes in the uid for the friend we want to use and a callback method.

void GetFriendsCompleted(IList uids, object state, FacebookException e)
{
    if (e == null)
    {
        Dispatcher.BeginInvoke(() =>
        {
            this.txtStatus.Text = "Loading Photos...";

            // get the albums for our first 20 friends
            for (int x = 0; x < 20; x++)
            {
                _facebookApi.Photos.GetAlbumsAsync(uids[x], GetAlbumsCompleted, uids[x]);
            }
        });
    }
    else
    {
        Dispatcher.BeginInvoke(() => MessageBox.Show("Error getting friends: " + e.Message));
    }
}

So now that we have our list of photo albums, we need to get the pictures in each album. With the albums retrieved, the first album in the list is usually the Profile Photos. To do this, we will use the Facebook.Rest.Api.Photos.GetAsyc method. We'll pass in an empty string for the subj_id, album id at index 0, new string array for the list of photo ids, and a callback method.

void GetAlbumsCompleted(IList albums, object state, FacebookException e)
{
    if (e == null)
    {
        Dispatcher.BeginInvoke(() =>
        {
            if (albums.Count > 0)
            {
                // get the photos from the first album, which is usually the profile pictures
                _facebookApi.Photos.GetAsync(string.Empty, albums[0].aid, new List(), GetPhotosCompleted, state);
            }
        });
    }
    else
    {
        Dispatcher.BeginInvoke(() => MessageBox.Show("Error getting albums: " + e.Message));
    }
}

Finally, this last callback will handle the photo's that were returned from each query. The person's most recent profile photo is located at index 0. To display these photos, we will create a new Image and then add it to a user control that was created to display the photos.

void GetPhotosCompleted(IList photos, object state, FacebookException e)
{
    if (e == null)
    {
        Dispatcher.BeginInvoke(() =>
        {
            // create a new image
            Image i = new Image();
            i.Source = new BitmapImage(new Uri(photos[0].src));
            i.Width = 140;
            i.Height = 140;
            i.Stretch = Stretch.Uniform;
            i.Margin = new Thickness(0, 0, 5, 0);

            // add the image to our user control
            this.ucPhotoAlbum.AddPhoto(i);
        });
    }
    else
    {
        Dispatcher.BeginInvoke(() => MessageBox.Show("Error: " + e.Message));
    }
}

Conclusion

So in this post we expanded on our last foray into the Facebook SDK and were able to retrieve the user's list of friends and then get the latest profile picture for those friends. Hope you enjoyed this brief look at the Silverlight Facebook SDK.

Code!

Here is a download of a small demo application that uses the steps that were just discussed. In order to run the application, you will need to set up your own Facebook application. Until next time, Sláinte!

FacebookMemoryPartII.zip (2.14 mb)

A couple of months ago, The Silverlight Blog announced the Facebook SDK for Silverlight. I have been wanting to get a post up about using this SDK, but it has taken a while. Anyway, this is part one in what will be a three part series of a basic overview of using a little bit of what the Facebook SDK has available.

The Premise

Gathering profile and friend list information is made quite simple in the SDK, so I thought that an easy demo application would be an implementation of the childhood game Memory. However there will be a slight twist. Instead of using the same picture to match, the game will randomly select two profile pictures from your friends and use those for you to determine the match. I will post a link to a demo of the application once there's a full working version.

Making the connection 

The first step in getting this game started was being able to get the data from Facebook, and this is done using Facebook Connect. The SDK makes this very simple. Using the Facebook.Session.BrowserSession object, you simply create a new instance of a browser session with your Facebook application key, add a login completed event handler, and call BrowserSession.Login. This will open up a popup window with the Facebook connect login.

BrowserSession _browserSession;
_browserSession = new BrowserSession(APPLICATION_KEY);
_browserSession.LoginCompleted += LoginCompleted;
_browserSession.Login();

Getting the Information

Now that the user had logged in to their Facebook account, we can go ahead and get the user id of the logged in user. First we create a new instance of the Facebook.Rest.Api class and pass in the new browser session that was just created. The method call used is Users.GetLoggedInUserAsync and we will pass in a callback for when the operation is complete and any sate we wish to pass along in an object. In this case we will just pass null.

// we use a private member variable so that it can be re-used
private Api _facebookApi;

// create the new api instance and call the GetLoggedInUserAsync method
_facebookApi = new Api(_browserSession);
_facebookApi.Users.GetLoggedInUserAsync(GetLoggedInUserCompleted, null);

Next we need to handle the callback from the GetLoggedInUserAsync call. The callback method takes in a long parameter for the Facebook user id, an object for any state that you want to pass along, and any FacebookExceptions that may have occurred. Once the user id has been returned, we will make another call to the Facebook.Rest.Api class to get the user's information. This method is Users.GetInfoAsync where we will pass in the returned user id and a callback method. We will again use null for the state parameter.

void GetLoggedInUserCompleted(long userId, object state, FacebookException e)
{
    // check that no errors have occurred
    if (e == null)
    {
        _facebookApi.Users.GetInfoAsync(userId, GetUserInfoCompleted, null);
    }
    else
    {
        // if any errors occurred, invoke a call back to the UI thread and show the error message
        Dispatcher.BeginInvoke(() => MessageBox.Show("Error getting logged in user:\n\n" + e.InnerException.Message));
    }
}

Now that we have the current users information, we can get the information we want to pull from their profile. For this demo we will just use their name and a small version of their current profile picture. We will also set a _currentUser object that stores the user's information that we will use later in the application

void GetUserInfoCompleted(IList<user> userDetails, object state, FacebookException e)
{
    if (e == null)
    {
        Dispatcher.BeginInvoke(() =>
        {
            // set our user object
            this._currentUser = userDetails[0];

            // set user information data context
            this.ucUserInformation.DataContext = _currentUser.current_location;
        });
    }
    else
    {
        // if any errors occurred, invoke a call back to the UI thread and show the error message
        Dispatcher.BeginInvoke(() => MessageBox.Show("Error getting user info:\n\n" + e.Message));
    }
}

Conclusion

So with these couple Facebook SDK api calls, we have created a new Facebook Connect session and retrieve the current users information. Personally I think that this takes one more step than necessary, but the calls are pretty straightforward. The next post will go over getting the list of friends for our current user and then getting the Profile Picture photo album for each friend.

Code!

Here is a download of a small demo application that uses the steps that were just discussed. In order to run the application, you will need to set up your own Facebook application. Until next time, Sláinte!

FacebookMemoryPartI.zip (2.11 mb)

Update: This example and the source code download below have been updated to run with the Visual Studio 2010 and Silverlight 4 RC versions.

The 3rd Dimension

Recently at work, my coworker Jimm Wagner thought it would be fun to see if we could accomplish creating a "live" 3d video using Silverlight 4, a couple of webcams, and some old school red and blue 3d glasses. With the new webcam support that is now available in Silverlight 4, making this work was actually very simple. The resulting 3d in the video isn't perfect, but there is some feeling of depth once the videos are aligned properly.

Getting Started

The basics for how to accomplish this are quite simple, use the new webcam support in Silverlight 4 to get a list of available video devices, take a couple of Rectangles and fill them with a video brush, and create a couple of pixel shaders to get the colors you want. A little more detailed look at how this all goes together, plus a download of the code, will be available after the demo.

Note: You will need the the Silverlight 4 runtime and at least 1 webcam plugged into your computer for the demo to work. The runtime is available for both Windows and Mac. This may run better in it's own window, link is here.

The Pixel Shaders

To create these pretty simple pixel shaders, I utilized the Shazzam Pixel Shader Utility to create the HLSL for the desired effects. The two effects that were created were Red Only, which removed any color from the image besides the red, and a Minus Red, which removed both the red and the alpha from the input source. The code for the fx files is as follows:

RedOnly.fx

sampler2D input : register(s0); 

// This shader will remove the green and blue colors from the source
float4 main(float2 uv : TEXCOORD) : COLOR  {
  	float4 color= tex2D( input , uv.xy);
 	 
	// remove green and blue
 	color.g = 0;
 	color.b = 0;
  	return color;
}

MinusRed.fx

sampler2D input : register(s0);

// This shader will remove the red color and alpha from the source
float4 main(float2 uv : TEXCOORD) : COLOR  {
  	float4 color= tex2D( input , uv.xy);
 	
 	// remove red and alpha
 	color.a = 0;
 	color.r = 0;
  	return color;
}

One handy feature in the Shazzam tool is that it will generate the postscript files as well as the .Net classes that you need to implement your pixel shaders. More info can be found on the Shazzam site.

The Silverlight

So the first thing we need to do is the get all of the available webcams that are plugged into the computer. This is handled in the main page loaded event of our main window. Once we get a list of available video cameras, we check to see how many were found. If there is only a single camera, we go head and set one of our sources to that camera. Otherwise, we will bind a couple of comboboxes to the list of our available cameras so that the sources can be set at a later time.

void MainPage_Loaded(object sender, RoutedEventArgs e)
{
    // get available devices
    ReadOnlyCollection devices = CaptureDeviceConfiguration.GetAvailableVideoCaptureDevices();
    _deviceCount = devices.Count;

    if (_deviceCount == 1)
    {
        // enable the capture and reset buttons
        this.btnCapture.IsEnabled = true;
        this.btnReset.IsEnabled = true;

        // disable the source selections
        this.btnSetSource.IsEnabled = false;
        this.cbRedWebCamOptions.IsEnabled = false;
        this.cbBlueWebCamOptions.IsEnabled = false;

        // check if red source is null
        if (_redSource == null)
            _redSource = new CaptureSource();

        // set the red source capture device
        _redSource.VideoCaptureDevice = devices[0];

        // check if blue source is null
        if (_blueSource == null)
            _blueSource = new CaptureSource();
    }
    else
    {
        // bind the combo boxes
        this.cbRedWebCamOptions.DataContext = devices;
        this.cbBlueWebCamOptions.DataContext = devices;
    }
}

So if we have more than one available video device, we will set the VideoCaptureDevice of each source in the click event of our btnSetSources button that will be enabled if more than one camera is found. We will also check to see if the same camera is chosen for both sources and will only use our _redSource if this is true.

// check if red source is null
if (_redSource == null)
    _redSource = new CaptureSource();

// check if blue source is null
if (_blueSource == null)
    _blueSource = new CaptureSource();

if (this.cbRedWebCamOptions.SelectedItem as VideoCaptureDevice == this.cbBlueWebCamOptions.SelectedItem as VideoCaptureDevice)
{
    _sourcesAreSame = true;

    // set video capture device
    _redSource.VideoCaptureDevice = this.cbRedWebCamOptions.SelectedItem as VideoCaptureDevice;
}
else
{
    _sourcesAreSame = false;

    // set video capture device
    _redSource.VideoCaptureDevice = this.cbRedWebCamOptions.SelectedItem as VideoCaptureDevice;
    _blueSource.VideoCaptureDevice = this.cbBlueWebCamOptions.SelectedItem as VideoCaptureDevice;
}

And now that we have our capture devices initialized, we can create our video brushes and start the capture. If there is only a single camera, we will set it up so that our two video brushes are using the same camera. If the camera(s) are already running, we will stop the capture and reset our rectangles.

void btnCapture_Click(object sender, RoutedEventArgs e)
{
    try
    {
        if (_redSource.State != CaptureState.Started && _blueSource.State != CaptureState.Started)
        {
            // make sure sources are stopped
            _redSource.Stop();
            _blueSource.Stop();

            // create red video brush if null
            if (_redBrush == null)
            {
                _redBrush = new VideoBrush();
                _redBrush.Stretch = Stretch.Uniform;
            }

            // create blue video brush if null
            if (_blueBrush == null)
            {
                _blueBrush = new VideoBrush();
                _blueBrush.Stretch = Stretch.Uniform;
            }

            // check the number of devices
            if (_deviceCount == 1 || _sourcesAreSame)
            {
                // set the red video brush source and rectangle fill
                _redBrush.SetSource(_redSource);
                this.RedRectangle.Fill = _redBrush;

                // set the blue video brush source and rectangle fill
                // since there is only one camera, both of the video brushes source will be the same
                _blueBrush.SetSource(_redSource);
                this.BlueRectangle.Fill = _blueBrush;

                // we offset the red rectangle to try and create the 3d effect for only one camera
                this.sldRedHorizontal.Value = -5;

                // ask user for permission
                if (CaptureDeviceConfiguration.AllowedDeviceAccess || CaptureDeviceConfiguration.RequestDeviceAccess())
                {
                    _redSource.Start();
                }
            }
            else
            {
                // set the red video brush source and rectangle fill
                _redBrush.SetSource(_redSource);
                this.RedRectangle.Fill = _redBrush;

                // set the blue video brush source and rectangle fill
                _blueBrush.SetSource(_blueSource);
                this.BlueRectangle.Fill = _blueBrush;

                // ask user for permission
                if (CaptureDeviceConfiguration.AllowedDeviceAccess || CaptureDeviceConfiguration.RequestDeviceAccess())
                {
                    _redSource.Start();
                    _blueSource.Start();
                }
            }

            // change capture button content
            this.btnCapture.Content = "Stop";
        }
        else
        {
            // stop input sources
            _redSource.Stop();
            _blueSource.Stop();

            // remove the rectangles fill
            this.RedRectangle.Fill = null;
            this.BlueRectangle.Fill = null;

            // reset capture button content
            this.btnCapture.Content = "Capture";

            // reset the rectangles
            ResetRectangles();
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message, "Error using webcam", MessageBoxButton.OK);
    }
}

The final piece to the puzzle is using the pixel shaders that we created and compiled above. We add them in the xaml by adding in the following namespace xmlns:shaders="clr-namespace:WebCam3d.Shaders" and then referencing it as follows:

<!-- On our Red Rectangle -->
<Rectangle.Effect>
    <shaders:RedOnlyEffect />
</Rectangle.Effect>
<!-- On our Blue Rectangle -->
<Rectangle.Effect>
    <shaders:MinusRedEffect />
</Rectangle.Effect>

Finally, I added in a couple of horizontal and vertical sliders that allow you to shift the two rectangles to get them lined up correctly for the 3d effect. This helps when using two different model webcams or just a single camera for input, plus the fact that my rig took slightly less time to develop than this one.

Conclusion

Hopefully this post was able to show how easy it is to implement multiple webcams in Silverlight 4 and add some simple effects to them as well. I am relatively new to Silverlight, but was still able to get a working demo up and running in a short amount of time using these techniques. Any comments or questions and suggestions on how this could be made better are more than welcome. Happy coding!

Code Download

Visual Studio 2010 RC Solution: WebCam3d.zip (78.00 kb)

Surfing the internet this morning, I came across some tidbits on Engadget that caught my eye of new gadgets and technology that would go quite nicely in my house.

3D At Home!

I had previously heard stories that Sony was planning to broadcast several of the World Cup games in 3D at certain venues, but according to this article, it sounds like several of the games will also be broadcast on a new channel that is launching, ESPN 3D. It also sounds like Discovery will be joining the 3D game as well, and what could be cooler than shark week in 3D. Long story short, I may need to upgrade my current tv unit, seeing as how the last time I bought a tv was so that I could watch the last World Cup in 2006 in HD.

Touch

Another area of tech that I am extremely interested in is touch. Having built several applications for the Microsoft Surface, I feel that touch and multi-touch computing are where things are heading. Not necessarily for much of the current work we do such as coding, but it definitely has the possiblity to expand consumer interaction in many ways. Enter the Light Touch from Light Blue Optics. This cool little gadget can turn any flat surface into a 10-inch touch screen and could be useful in retail situations, as is depicted in the pics from the Engadget article. Check out this simulated demo from the Light Blue Optics site:

Touch + Touch + ... + Touch = Multitouch

Another item that I came across on Engadget was this multitouch monitor from 3M. This monitor boasts the ability to track 10 points of contact, making it possible to use both hands and is Windows 7 compatible. Looks like a step in the right direction for single user multitouch. Now, if I can only convince work to buy me one for "testing"...

What's going on?

This will be the home for the blog that I am finally starting and have been planning on doing for over a year. Reasons it took this long:

1. Working for Phenomblue, there always seems to be something more important to work on than my own blog..plus I actually get paid for doing their work..so I have that going for me
2. I golf quite a bit, more than I should probably mention, and the weather was nice in my neck of the woods this last summer
3. I have a tendency to not always finish projects, so this is hopefully a step in the right direction
4. Beer

This isn't where I parked my car...

Hopefully there will be other useful information here, since I don't think I'll be much help finding your car. The plans for this blog include, but are not limited to, cool projects that I have worked on or messed around within the realms of Silverlight, WPF, Microsoft Surface, and javascript to name a few. I also recently upgraded to an HTC Hero that runs Google's Android OS, so hopefully I can find some time to tool around with it, but my Java is a bit rusty.

We deal quite a bit with social media at work, so you can expect mashups galore with the ever growing number of api's (Twitter, Facebook, MySpace, etc...) that are becoming available and can provide some different and unique insights on what really is popular or cool.

What's with the title of the blog?

I'm a golf fanatic, some would say obsessed, and I would kindly agree. The title comes from a quote from the King himself, Arnold Palmer:

"Golf is deceptively simple and endlessly complicated; it satisfies the soul and frustrates the intellect. It is at the same time rewarding and maddening - and it is without a doubt the greatest game mankind has ever invented."

I feel the like the two phrases "deceptively simple" and "endlessly complicated" work very well to describe the world of programming that I work in every day as well as just what life can be in general, and I know from experience that they definitely apply to the game of golf. Plus, you have to figure that a man that has a drink named after him is a pretty smart guy.

Let the games begin

Going forward, I hope there will be hopefully be some informative, maybe entertaining, maybe useless, posts about programming with the possibility of some golf commentary sprinkled in there as well (no Tiger scandal posts, I promise). Oh, and sorry other developers for using the cliché "Hello World" title, my computer wouldn't let me name it anything else since it was my first post...believe me, I tried.