AS3 — No comments
24
Jan 12

SmoothBitmap – How to enforce pixel smoothing on a Bitmap

A common oversight when using Bitmaps with loaded content is that Flash will revert a Bitmap’s smoothing parameter to false when you replace its bitmapData. It’s simple enough to fix, but since you may not know if someone is going to replace the bitmapData of a Bitmap you have created – then it’s often better to code defensively around it.

This little SmoothBitmap class is for just such an occassion. Instantiate it like a regular Bitmap and, no matter what another developer does with it, smooth pixels when scaling/rotating will be ensured.

WTF — No comments
14
Jan 12

CODING WRONGS – Where do I start with the bad?

It gets scary out there sometimes. During my freelance career I've worked a lot of different companies and have seen such coding horrors as you cannot imagine. So I thought I'd start immortalising some of them - so that we can all learn better coding practices, by looking at the bad.

Starter for 10 - What's wrong with this picture?

public function set someProperty(value:String):void
{
    var newPixels:BitmapData = new BitmapData(someUint, someUint, true, 0);
    someBlitUtil.blitStuffTo(newPixels, value);
    someBitmap.bitmapData = newPixels;
}

If it's not immediately obvious, the fubar here is the potential replacement of a Bitmap's BitmapData, without explictly disposing any existing BitmapData. I see this kind of thing quite often and it's the source of many a memory leak. AVM2 isn't that great and dealing with this kind of situation and there's a crucial difference between GC cleaning up out-of-scope objects for you and things like BitmapData: GC will reclaim the memory associated with objects 'when it feels like it', whereas explicitly calling the 'dispose' method of a BitmapData will immediately give you back that memory. In the case of hardware accelerated setups, the memory associated with the pixel data itself (video memory) will be reclaimed immediately. You shouldn't make more work for GC when you can avoid it - defensive programming is always best!

AS3 / Testing — No comments
10
Jan 12

Object pooling utility updated

Having just got back from an awesome break in Thailand and Taiwan, I just updated my object pooling utility. Thanks to Ostra Ceruzka for raising an issue with its strict mode functionality with me - all fixed now! Serves me right for not writing enough tests, huh?

AS3 — No comments
31
Aug 11

TextField.getRawText() what it does

I was recently creating an API that required extending TextField and happened across the getRawText() method. I assumed this returned the text from the field without formatting or something - so I looked up the AS3 docs for flash.text.TextField.

Nothing there - gee thanks Adobe. A quick search turned up this which, it turns out, isn't quite accurate.

So, with a tad of testing, it appears that getRawText() returns the text, stripped of any HTML tags (if you had set htmlText). I now wonder if this is faster than using a RegEx to strip the tags and why Adobe didn't document it?

AS3 — No comments
29
Aug 11

Loan Shark – fast object pooling

Loan Shark AS3 object pooling utilityA couple of years ago, I created an AS3 object pooling utility for a games project I was building. Since then, I've used it quite a few times, in order to speed up apps and improve resource management, easing the load on the garbage collector by reusing objects instead of recreating them.

While object pooling isn't a magic bullet to speed up every use case, it works especially well with custom classes that are heavy to continually contruct and destroy. A good example is my History of the World project, which uses an object pool for item renderers, instead of creating and destroying them as you navigate around - press ALT+CTRL to bring up the resource debugger, which shows a little information on its usage.

I recently updated the utility, improving its performance, adding features and putting loads of unit tests around it. It's now hosted it over at GoogleCode. Using it is a simple as:

import org.kissmyas.utils.loanshark.LoanShark;

var pool:LoanShark = new LoanShark(SomeClass);
var someInstance:SomeClass = pool.borrowObject();
someInstance.doStuff();

// Instead of nullifying an object, check it back into the pool
pool.returnObject(someInstance);

Animation / Flash / Videos / Work — No comments
20
Aug 11

Lurpak Breakfast – how it was done

I thought I'd give a quick insight into how the animation effects in one of my projects were acheived.

Scott Bedford, former Creative Director at Carlson Marketing, posted this video of a project we worked on a while back, for the Lurpak Breakfast campaign. I created all the animation prototypes for the various effects used throughout the site, some of which can be seen here. The site won two DMA awards, but I'm most proud of the crumbs animation and the code-generated interactive steam effect - similar to the one you'll see on my homepage.

Techie Breakdown

  • Crumbs animation. 1000 Bitmaps random position themselves until around the edge of the bread mask shape, animated with simple mouse interactive physics - force, velocity, momentum and friction all tweakable
  • Steam effect. Perlin noise moving through another perlin noise BitmapDisplacementFilter, to which user generated displacement can be applied, then all blurred
  • Egg Timer animation. Particle system with basic physics and just a draggable mask
  • Do Not Disturb tag. Maths-based animation for the swing only, the rest is old-school timeline animated
  • Fry-up triple banner. Three banners synchronise object positions/velocities using LocalConnection to send packets with a TTL applied to avoid a feedback loop
  • Spinning letters. TextMetrics used to break a populated TextField into separate letters, each one animated into a simple 3-D engine I knocked up, with simple physics used to achieve the swirl motion
  • Hang-over breakfast. Just a blurred mask, though I prefer my version from my original - alpha a blurred copy of an image over the original for a proper hazy effect
  • Other animation. Uses a combination TweenMax, maths and frame-by-frame, e.g. pancakes, bedroom door
  • Not mine: Wise-crack banner, breakfast tray messenger banner, down tools drawer, coffee bean counter, flapjacks, emails
Apps / AS3 — No comments
09
Aug 11

How the hell do I build this?

I had a conversation yesterday with a friend and colleague about how his company should standardise their development environment for all Flashers - be they contract or perm, junior to senior.

He, like many of us, was sick of contractors building projects and leaving them in various states of repair. Required libraries or fonts are often missing, bits of code never even get checked into source control and, frustratingly, it is often unclear how to build a project. The makeup of Flash projects can vary from an FLA file/s full of timeline based code, to source code set up to compile under one specific, mystery environment.

The problem:
You need to set some kind of reasonable standards, so that ActionScript projects can be easily verified, maintained and recompiled, not necessarily by someone with intimate knowledge of the OS, environment and the project - ideally even a developer without intimate knowledge of ActionScript or a copy of Flash CS5 and Flash Builder to hand.

The solution/s:
There are obviously many ways to skin this cat. But, the way I see it, the best solution needs also to be reasonable, achievable by everyone and cost-effective for a typical digital agency. As such, the 'best' solution may not be the 'ideal' solution - by which, I mean an idealistic solution based purely on software development 'ideals'.

Flash IDE
We have to start somewhere and, at the risk of a flaming, I'll act as its advocate for a bit. There will often be a need for those FLA files knocking around and you won't get designers building their banner's with the Flex SDK. However, since the Flash IDE isn't free, open source, understood by non Flashers and (with the exception of CS5) creates nasty binary balls of mud (namely FLA files), we'll assume from here on in that we're talking about compiling project with the Flex SDK.

Flash Builder
Adobe's own latest development environment for Flash/Flex, built on the very popular and mature Eclipse is certainly feature-packed and already industry standard. But is it the sanest choice to enforce that everyone use this particular environment, just so projects are more maintainable? Will it work and, since it's not free software, is it even cost-effective? Personally, I think perhaps not. Since Flash Builder isn't free, requiring its use for all Flash projects within a company will probably solve one problem and create all new ones.

FlashDevelop
FlashDevelop is my favoured editor and, without getting into the FDT vs FlashDevelop vs Flash Builder debate - I favour it primarily because, whereever I work, I can always get IT to install a copy on my machine, without having to wait for budget approval, bring my laptop instead, etc. However, FlashDevelop is currently for Windows only and is still just one development environment. Even though it's free and open source, we want to abstract away a project's configuration and setup from any software that isn't also cross-platform and industry standard.

Maven
So why not enforce that everyone builds and configures their projects so that they can compile under Maven from a POM? I think it's a little unrealistic to expect every calibre of ActionScripter to even know what Maven is. At very least, it would create a rather high barrier to entry for prospective developers, making recruitment even more difficult for any company. I agree that it's a bonus for many, larger projects that may need to pull in dependencies from other projects.

Ant
Ant is a cross-platform solution for software automation, built on Java. Since it's open source, free, industry standard and pretty easy to set up and use, I'd say its the best choice for configuring the building of projects in a standardised way, without tying anyone to a particular code editor, platform or requiring expensive any software.

Ant can be integrated into most development environments and provides a sensible 'how the hell am I supposed to build this?' answer to any project. This also means that, for those people that use it, the Ant script can be used for building with Maven/Hudson, for automatically ensuring all projects will build - even if you only use this to ensure a contractor has left the project in a buildable state.

I also found this helpful article on integrating Ant with FlashDevelop - so if you like that free, open-source feeling, then take a look.

AS3 — No comments
07
Aug 11

Fastest way to add multiple elements to an Array / Vector

In a simple situation, where you wish to add many elements to an Array or Vector, you might just do:

var input:Array;
var output:Array;
while (input.length)
    output.push(input.shift());

However, the sizes of both Arrays are manipulated for each loop, which will have an adverse impact on speed and memory usage. So, we could cache the length of the input Array and not manipulate it:

var input:Array;
var output:Array;
var inputLength:uint = input.length;
for (var i:int = 0; i <inputLength; i++)
    output.push(input[i]);

But we're still growing the size of the output Array incrementally, which is very bad. Since we know input.length in advance, we could grow the output Array to its new size just once, before the loop:

var input:Array;
var inputLength:uint = input.length;
var output:Array;
var outputLength:uint = output.length;
var newOutputLength:uint = outputLength + inputLength;
output.length = newOutputLength;
for (var i:int = 0; i <inputLength; i++)
    output[i + outputLength] = input[i]);

This is OK, but still involves a loop. If only we could push multiple elements into the push method in one go. Well, we can - enter the apply method. Since Array.push accepts multiple arguments (something rarely used) and apply allows us to pass an Array of arguments to any Function, one line and we're done:

var input:Array;
var output:Array;
output.push.apply(null, input);

This works out faster and more memory efficient than the other methods. It works nicely for Vectors, too. If anyone has a faster method of doing this, do let me know.

← Older Entries