Associating execution of Powershell scripts with the default open action in Windows 7

I've been using Powershell a bit lately and finally got to the point where I'm using it so much I want to be able to simply double click on a *.ps1 script file and have Powershell execute it.  So, in the interest of creating an internet based reference that I can Google myself when I forget this:


*** Note:  Always backup your registry before editing it unless you really like rebuilding things ***

Basically you need to create a default value inside the registry key (if the sequence of keys doesn't exist, create them):

     HKEY_CLASSES_ROOT\Microsoft.PowerShellScript.1\Shell\Open\Command

Leave the value with the name '(Default)', make it of type REG_SZ, and set the data to:

     \system32\WindowsPowerShell\v1.0\powershell.exe -command "& '%1' "

Where "" is the location of your Windows directory.


The sequence "& '%1' " is important.

BTW, I highly recommend that you make sure your Powershell script execution settings are set to require remote scripts to be signed properly.

When your favorite Firefox extension gets 'obsoleted' on you...

...you can sometimes get around waiting for the developer of the extension to update it for whatever version of FF you're currently on.

Often, the extension will have an attribute specifying the greatest version of Firefox that it can be used on.  This is, of course, a safety mechanism to avoid having a new version of Firefox break the extension and everyone start screaming at the extension developer (which is always a stupid thing to do irrespective of your reasoning) about how their extension is crap/broken/stupid/et cetera.

I have a Firefox extension that I dearly love and for the past few weeks, since I let Firefox update me to version 6.0.* I have been without it.  I ***NEED*** my Morning Coffee I tell you.

So, finally getting my lazy a**, I decided to look into this and found a version attribute in the extensions install.rdf file that limited it to 4.0.*.  I changed that to 8.0.*, and then started up Firefox and voila - lo and behold morning coffee is on.  Thank you God (and Shane Liesegang.)

So, to do this yourself:

1.  Find your morning coffee add-on, or download it (it should be a file ending in *.XPI)

2.  Unzip it (it is basically a zipped folder)

3.  Edit the install.rdf file, changing maxVersion to 8.0.* (or some value matching your current Firefox version or higher (mine says em:maxVersion="8.0.*")

4.  Recompress the folder (make sure you are inside the unzipped folder and select all of the items in the root of the directory because many archiving utilities create an extra folder to store your zipped content in when the compress)

5.  Change the file extension, if necessary, to *.XIP as this is the default extension extension *chuckle* - your honor, your honor...

Did this about 3 months back - Chepe's Monster Burrito Challenge

If you eat it, in any period of time you can muster, you get a t-shirt.  Trust me, the t-shirt is NOT worth the effort of eating this behemoth.

By the way, in the picture, her arm is nearly touching the back of the burrito - it isn't a trick of perspective.  The thing weighs (supposedly) more than 6 pounds.

The only good things are that it is very tasty (for the first 70 bites or so) and it is cheap - only around $15 if I recall correctly.

I will not be doing this ever again.

F**$#&% Java Policy Files

If you have ever had to modify a policy file, let me warn you of a wrinkle that you may run into IF your applet/java code needs to perform an operation that is authorized by the policy file BUT IS CALLED VIA JavaScript.

Guess what folks?  Java doesn't trust JavaScript any more (and hasn't intermittently over the past 5 years or so - sometimes trusting, sometimes not) so just because you gave your code a valid policy file grant, any code triggered via JavaScript will run as if being run outside the Java codebase (which in a way it is.)  This means that you have two options, one of which is not palatable, and the other can break backwards compatibility in your codebase.

(1)Grant permissions without using the codebase attribute (this is very very bad as your permission change will therefore grant the same permissions to ANY applet that the user runs into.)

(2)Surround the code that needs permissions privileges (and can be called via JavaScript) with a doPrivileged block.  The downside to this is that early versions of Java don't support this functionality; ergo you are (probably) forced to go the trusted/signed applet route (not good for many reasons.)

Luckily for me, I only need this functionality inside of a tool that is hosting my Java code, so I can put the non 1.1.8 jdk compliant code in my dynamically loaded adapter class that only ships with the offline tool.

Anyhow, I hope someone else trying to figure this out learns from this.

If your applet needs policy file permissions and your applet will be called from javascript, you must not only grant the applet the permissions in the appropriate fashion but also surround the code that can be triggered via JavaScript with a doPriveleged block.  This is because Java's runtime no longer executes javascript with the permissions levels of the applet.

Skeletal Animation – An overview

I have been meaning to write a series of blog entries around the basics of skeletal animation for a while now but have been unfortunately too busy to do so – until now, so let’s put our learning hats on!

When you need to animate a 3D object in a game or simulation there are 3 primary ways to accomplish the task:

(1)Hierarchical object animation using keyframes

(2)Vertex Animation

(3)Skeletal Animation

Hierarchical object animation is when you have multiple meshes which are, typically, arranged in a parent-child fashion through some sort of scenegraph.  Animation data is typically stored as separate translation and rotation (and sometimes scale) components and each object is animated relative to its local frame of reference.  This works fine for when the object is something like a helicopter and you need to rotate the main and tail rotors; however, when trying to articulate a more complicated and less segmented logical object such as a humanoid character, animation can only occur on the transforms for the object – no vertex data can be changed.  This means that constructing a human out a mesh hierarchy (with a head mesh, neck mesh, chest mesh, upper arm mesh, et cetera – all the appendages you wish to articulate) leads to block or segmented animation because, for example, the forearm object isn’t really connected to the upper arm so that when it is animated the ends of the objects don’t touch completely and your characters looks like they were created out of blocks.  Interstate 76, an amazing old game which I still occasionally replay just for the cut scenes, was animated in this fashion.  Suffice it to say that since that time animators and game developers have been looking for solutions with better visual fidelity.

Vertex animation is when a mesh is manipulated on a per vertex level by comparing one complete set of the mesh’s vertices against another complete set of the mesh’s vertices (each of the sets of vertices representing a particular keyframe of animation data) and interpolating a position between the two based upon how far between keyframe times the current animation clock is.  This approach gives the artist the most creative control and the greatest ability to animate; however, it is very memory intensive and requires art content files that are very large since each keyframe of animation is a complete snapshot of the mesh at a given point and time.  Quake’s MD2 file format is an example of vertex animation – another problem with vertex animation is that it is difficult to apply multiple simultaneous animations to a mesh being animated in this fashion.  Since the animation data is a complete snapshot of the mesh each animation stomps all over the previous one that was applied; now, there are solutions to this that modify vertex animation so that you are using ‘relative vertex animation’ data and you can combine and blend somewhat (and save art content file space by discarding unchanging vertices on a given keyframe) but ultimately as your models scale up in complexity, vertices, and polygons this approach has diminishing returns.  Vertex animation is still a very important approach to the non real-time rendering world; however, in the real-time arena it is rarely seen except for extremely complicated situations and sometimes for facial animation or lip synching.

Skeletal animation is a hybrid of the previous two methods.  The mesh representing the object is not manipulated by interpolating between two complete sets of vertex data (as is the case in vertex animation) but instead by moving treating the vertices of the mesh as if they were the ‘skin’ of the mesh and moving the skin to fit over a skeleton.  The skeleton is like the hierarchical object animation from the old days except that the skeleton, just like the skeleton in your body, is a hierarchy of ‘bones’ (sometimes referred to as ‘joints’) and even though you animate the skeleton, you never actually bother to draw it.  This is because we only want to animate the skeleton because we’re going to force the skin to go along with it.  Half-Life is an early example of a game that used skeletal animation.  Why don’t we simply animate the skin this way?  For all the reasons why we just explained that vertex animation is no longer in favor in the real-time world.  By only storing the rotation and translation (potentially other factors as well) data for each bone for a keyframe of animation we save tons of space in our art content files, and we gain the ability to simply combine animations and blend between them.  We gain performance advantages over complicated relative vertex animation systems when the model’s topology scales (more polygons, more vertices), and we gain the ability to add FK/IK capabilities into our system that would be virtually impossible with vertex animation (any system I can imagine to support this via vertex animation would ultimately require you emulating a skeletal system.)

So, now that I have explained the reasoning why I, and many others, use skeletal animation, let’s start explaining how it works.

The good news is that skeletal animation is actually VERY simple.  The bad news is that it usually either partially explained or people use different terms for differing things.  I will do my best to explain it as simply and yet thoroughly as possible.  The other bad news is because the world is an imperfect place, obtaining an example of skeletal animation data you can use can be difficult because you’re just now learning how it is supposed to work so it can be difficult to discern why art content produced by your artist doesn’t seem to work (is it you?  Is it the artist?  Is it his/her exporter?  Et cetera.)

Luckily, I will provide you with an example COLLADA XML file (*.dae) that has a walk animation included.  We will use the COLLADA format because there are moderately usable exporters for all the major art pipeline tools (Maya/Max/XSi) and your art guy/gal will most likely have experience with one of those tools.

So, ultimately, when this series of posts is over, you’ll be able to import a COLLADA XML file, pull out the mesh geometry, pull out the skeleton, and pull out the animation data, then play it back in your application.

Windows 7 64-bit and Samsung Kies Mini

I was shocked to find out that AT&T and Samsung had finally provided a Froyo (Android 2.2) update for the Captivate Galaxy S phone.  All I had to do was download Samsung's Kies Mini firmware updating application (the version available was actually an AT&T modified stripped down version) and setup my phone correctly, backup critical data and press 'Upgrade.'

Of course, it never works out that way in the real world but I must admit that even a jaded and cynical software engineer like myself was disgusted and disappointed when every single time I connected my Captivate to my computer with Kies running, the Kies application would identify the phone and then promptly crash.

I Googled, Googled some more, tried compatibility settings, running as Administrator, I even tried using a Windows XP virtual machine in case it was a 32-bit issue - sadly Virtual PC 2007 (what I use on Windows 7) doesn't pass USB to a VM.

In any case, I was getting more and more frustrated and was ready to quit when I ran across an obscure tiny little message on some news server somewhere where a guy mentions - "Oh, yeah, and if you have IE9 installed on your machine, take it off."

Well, I just happened to have an IE9 release candidate installed.  How that crashed Kies escapes me since you'd have to be a pretty crap software engineer to have not tested your Windows only application, which you are releasing to MILLIONS of people to use, against IE6, IE7, IE8, and IE9 - but hey, Samsung are weird that way.  They make some wonderful things and somehow drop the ball on the really trivially simple things.

Long story shorter, uninstalled IE9, ran Kies Mini, phone showed up, chose 'Upgrade', a few minutes later I'm running flash on my Android phone.

AppleScript to add a 'new file' capability to Finder

Another convenience function you may wish to add to a button in your Finder toolbar is a 'new file' button that will deposit a blank file named 'NewFile' in the current Finder window directory. It also auto increments a counter if needed to ensure the new file doesn't overwrite an existing file. The code is below:

tell application "Finder"

#Create filename (avoid overwriting)
set current_path to (POSIX path of (the folder of the front window as text))
set good_filename to false
set loop_count to 0

repeat while good_filename is false

if loop_count is equal to 0 then
set NewFileName to (current_path & "/NewFile")
else
set NewFileName to (current_path & "/NewFile" & loop_count)
end if

if exists NewFileName as POSIX file then
else
do shell script "touch " & NewFileName
set good_filename to true
end if

set loop_count to (loop_count + 1)

end repeat

end tell