I feel slightly dirty, having not only done some work for an oil company recently, but also just having made a banner. I usually tell clients that banners are against my religion, but made an exception in this case because it involved doing some challenging code-driven animation. Check it out on Bannerblog.
Category: Uncategorized
I recently needed to create something where a chain of spring dynamics points is connected with one smooth, seamless curve. After much mathematical wrangling, here’s the result of my efforts…
Here are a few simple tricks that may help the performance of your code/graphics intensive Flash movies. This is not an exhaustive list, by any means, rather some of the more effective performance tweaks to try out on your projects. There are the usual sensible coding tricks, like using local variables for oft-used references within functions, or planning your code loops carefully and breaking out of loops whenever feasible - but you should be doing these already. I'll be adding to this post as and when I feel necessary, but will generally avoid the more granular tricks, such as bytecode optimisation. Some of those methods are too complex to explain in simple terms here and generally have a low effort-to-benefit ratio anyway:
Use scrollRect in conjunction with cacheAsBitmap. The cacheAsBitmap parameter of a movieclip can improve performance dramatically, but will cause problems if the render area of the movieclip gets too large (e.g. larger than 2880 in width or height), regardless of whether it is cropped by the viewable area of the Flash Player. The solution is to use scrollRect to constrain the rendering area to desired limits, in this example, the stage width/height:
import flash.geom.Rectangle;
scrollRect = new Rectangle(0, 0, Stage.width, Stage.height);
cacheAsBitmap = true;
scrollRect = new Rectangle(0, 0, Stage.width, Stage.height);
cacheAsBitmap = true;
Create bitmap snapshots of complex movieclips. Where you may have a movieclip full of layered graphical effects that isn't animated, you can save a lot of rendering time by creating a snapshot of the movie. Similar to the cacheAsBitmap parameter, but will improve performance further if your movieclip comprises many lines or alphas. The following function shows a quick and dirty way of duplicating a movieclip as a snapshot of the original:
import flash.geom.*;
function createSnapshot (base:MovieClip, mc:MovieClip):MovieClip {
var bounds = mc.getBounds(base);
var bmpWidth = bounds.xMax-bounds.xMin;
var bmpHeight = bounds.yMax-bounds.yMin;
var bmp1 = new BitmapData(bmpWidth, bmpHeight, true, 0x00000000);
var snapshot = base.createEmptyMovieClip("snapshot"+base.getNextHighestDepth(), base.getNextHighestDepth());
snapshot._x = mc._x;
snapshot._y = mc._y;
var rect = new Rectangle(0, 0, bmpWidth, bmpHeight);
var pos = new Point(0, 0);
bmp1.draw(mc, new Matrix(mc._xscale/100, 0, 0, mc._yscale/100, mc._x-bounds.xMin, mc._y-bounds.yMin));
snapshot.attachBitmap(bmp1, 1, "auto", true);
snapshot._x = bounds.xMin;
snapshot._y = bounds.yMin;
mc.unloadMovie();
return snapshot;
}
function createSnapshot (base:MovieClip, mc:MovieClip):MovieClip {
var bounds = mc.getBounds(base);
var bmpWidth = bounds.xMax-bounds.xMin;
var bmpHeight = bounds.yMax-bounds.yMin;
var bmp1 = new BitmapData(bmpWidth, bmpHeight, true, 0x00000000);
var snapshot = base.createEmptyMovieClip("snapshot"+base.getNextHighestDepth(), base.getNextHighestDepth());
snapshot._x = mc._x;
snapshot._y = mc._y;
var rect = new Rectangle(0, 0, bmpWidth, bmpHeight);
var pos = new Point(0, 0);
bmp1.draw(mc, new Matrix(mc._xscale/100, 0, 0, mc._yscale/100, mc._x-bounds.xMin, mc._y-bounds.yMin));
snapshot.attachBitmap(bmp1, 1, "auto", true);
snapshot._x = bounds.xMin;
snapshot._y = bounds.yMin;
mc.unloadMovie();
return snapshot;
}
Use the opaque window mode trick - sparingly! Setting the wmode=opaque HTML parameter of your Flash object can improve rendering performance, but at a potential cost. Not only does it make the rendering order of movieclips and frames more 'lazy', but will effect keyboard interaction adversely in some browsers (especially FireFox). Use with caution.
I'll be updating and tracking back to this post occasionally, so stay tuned...
I was recently asked about the problem of loading XML from within a class to trigger an arbitrary method. The problem was: the onLoad event triggers on the XML instance, not the class creating it. This could probably be worked around with the Delegate class, but in the past I've simply extended the XML class itself, overriding the onLoad handler and adding a callback object that's passed in (along with some error checking). It's partnered with an XMLLoader class, the source and simple demo of which you can download here.
I went to an interesting talk on Enterprise Integration Patterns at SkillsMatter the other day. Though aimed primarily at Java developers, there was not a scrap of code and the concepts discussed could apply to development in almost any language.
The focus of the talk was: good, simple code design versus just using lots of clever inheritance to create complex-looking, unmaintainable frameworks. Common sense really - it's the kind of 'form over function' approach that we're all too aware of plaguing the creative world that applies to programmers too. I'm sure many developers (especially us contractors) have personal experience of this. Be it having to use over-complicated web services, where three lines of PHP would do the trick. Or being forced to base a project on some client's ailing framework, written in the dark ages, with little or no support.
However, it's the reality of having to integrate with a host of unknown systems that keeps the job interesting, I suppose. It does mean, however, that the Holy Grail of code reuse (even across similar projects) doesn't often happen the way we'd like. How many times have I heard "it's OK, this half-finished project is all in classes, so it should be easy to repurpose"?
With such specific requirements to any individual project, some classes and knowledge can be reused, but the more complex the program structure, the more difficult it is to grasp mentally. Also, design patterns mean exactly that: patterns. Not: "this is the way we do every project", but general approaches you learn from experience are more apt for a given task.
The London Flash Platform Users Group is running a meetup tonight about (among other things) connecting and controlling Flash with the Nintendo Wii controller - how cool is that? For those that can't make it down to the Cosmo Bar in Barbican, they are apparently broadcasting the event here.
...see you there!
Comments