Flash: Blend Modes and Optimal Contrast
Got some chance to play with blend modes this weekend...cool stuff. While the example is neat looking, In particular was looking for a solution to (dynamically) contrasting against an unknown background, as is likely to happen with developing tools with unknown content, else whatever you pick will break.. This is easy to see on my TV programs, where the 'bug' has to show up against an rapidly changing background of. Say showing white text against a dark background and a light text against a dark, versus the normal technique of white text with a dark blur around it, to always have an moat of safety around it.
Flash blend modes exploration on high contrast backgrounds
What you're seeing is a 3 line text with:
Snow (white and black)
Snow (50% gray, 50% gray 50% transparent)
Snow (black and white)
Repeated a bunch of times, in a clip with the blend mode listed at the top.
Unfortunately in the gray zone most techniques just fail. Helped me realize what's really desired is some intelligence as to what is beneath the image to pick a suitable offset, say at when 50% gray, just choosing white or black based on the dominate color of the page. Leading to the only way to get high contrast between menu items is the halo..which I suppose is more consistent from a usability, if less integrated with the image.
Kaourantin the implementer of these in the flash player has great information on how they behave, and the impact on performance. As mentioned here To use Alpha and erase blend modes you have to do extra work: 1) put them in a parent movie clip, and turn that parent's movieclip blend mode to 'layer', else they don't show up at all.
Contrast this approach with the use of ColorUtils and Adaptive Color
AS3: Image Posterization + ColorUtils + Adaptively Colored UI’s
Ported this posterization algorithm to AS3 . It will be in the com.troyworks.ui.ColorUtil, when released.
Posterization is basically compressing the color range of a photo into something smaller. Anybody who has worked with converting to 'indexed color' in GIF or PNG knows what this means. Say you have a sun against a sky of blue. Since there are only say 8 colors, there is no need to have room for 24bit color across the entire range, making it dramatically smaller. The other use is for artistic purposes,
Porting one to actionscript has allowed me to create something nifty. One of the design challenges when working with dynamically loaded images is complimenting the colors in the loaded image in the surrounding UI elements., and from a useability perspective making sure that text and UI elements are sufficiently contrasting from whatever dominate color is chosen, else they dissapear...is that "cut or delete?"
So towards that end, I created this prototype, click on one of the indexed colors to change the ui, the text will choose from one of the other color bands. The title will pick either white or black to attempt whatever the best contrast is from the selected color.
Click on any of the colored bars to have the entire UI adjust..all colors originate from the thumbnail.
This was accomplished by first posterizing the loaded image (the second image) and indexing the colors with a bandpass filter (filtering out anything too black or too white) via com.troyworks.ui.ColorUtil , sorting by how often the color occurs in the image to generate the histogram. Used com.troyworks.core.tweeny.Tny to do the color tweening. com.troyworks.data.ArrayX to get a random color from the bands.
From a design perspective, it's interesting how the low occurance spot colors when selected makes the image seem more 'playful' while the more common dominate ones 'serious'. I find myself wanting to put a better color distance in, to filter out things close to grays from the options.
There are also method to get shades and hues from a given color, but no examples yet.
All in all a fun way to spend a few hours this evening, while listening to Lily Allen.
AS3: Prelude to Tweeny, a fast and flexible Tweening engine
So I've been working over the weekend on the Tweening engine based on Cogs affectionately called Tweeny. I find it highly amusing as I've been working in Flash since Flash 4, I have built so many presentation engines it borders on comical when every new client inevitably asks for a powerpoint lite clone, and consider myself relatively advanced,..yet how much of a loop this one threw me for.
WhileI had an AS2.0 class already working, it's taken me 3 days to get the basics working in AS3.0. This is because yesterday I totally got schooled on Matrixes with Senocular's most excellent tutorial, (my brain still hurts) and then excited by Penner's lurking MatrixTransform and ended up scrapping several paragraphs that comprise most the standard tween engines. I find myself building this next presentation engine in a way that bears no resemblence to most engines I've used or seen, partly due on the architecture difference between AS3.0 and prior, and partly expanding the role of Tweening beyond the simple display classes. Every time I added a new feature or solved a bug, I found a way to make things simpler.
Matrixes are cool, as you can get away with just easing the Begin and End matrixes rather than doing every calculation, plus you get the ability to offset the registration point and skew, features both very useful for the Authoring type interfaces and kids content I'm creating. More power and more speed to boot! In running performance tests, it's about 2x faster than setting DisplayObject.rotate, DisplayObject.width, scale etc as most tween engines do. Not that running those scripts are typically the limiting factor relative to the overhead in rendering, but still it's nice to know that the underlying code isn't a bottle neck.
Like most Tween engines, Tweeny supports a pluggable easing that affects multiple properties (x, y, width etc) with individual ranges (x[-5, 100], pan[-1,1]). But something my math-whiz girlfriend help me realize was that since duration is fixed, the easing equasion (often filled with expensive Math operations) can be calculated once as the 'normal' and then scaled to the others ranges, cheaply with simple * + . This should significantly reduce tweening calculation overhead,...and dammit I like smart particles flying at 60fps!
To further that I realized that the normalized calculation, is easy to broadcast, so that other listeners keep in synch, and can conceivably modularize or patchwork tweens. One of the things that I've wanted to try for awhlie was a way to balance out top-down easing approaches with bottom up physics routine. This usually involves Euler or Verlet accumulation and integration of forces, but most tweening engines are rather possessive when it comes to updating display objects...only one at a time else they start overwriting, where's the fun in that?
Some other features I like, Sound or SoundChannel volume and pan, colorTransform tweening (which I use a lot for configuration dynamically styled UI's) easier constructors for Bounce and Elastic's extra params which I use with kids games.
One thing that I'm not currently planning on supporting soon is a JSON or XML based interface. I find it poor programming practice to do
TweenEngine.create(target, duration, {x:1,y:2, ....})
in AS3.0 when you can do:
var t:Tweeny = new Tweeny();
t.initFrom(target,duration);
t.x = 1;
t.y = 2;
t.addEventListener(...)
t.startFromBeginning();
Because using fully typed classes allow for autocomplete to help fill out the values, offer stricter type checking and setting of defaults. When they are on a line by line they are easy to comment out to turn on and off. There isn't any overhead to parse XML or JSON into useable values. Since it's part of the Class definition it should also be significantly faster than dynamically allocated Object properties on the prototype.
Keeping a tween around, keeps memory and garbage collection from churning, especially for most applications where the tween is reused over and over again to put thing back and forth. I realize why many tween engines opt not to go this route as managing transitions on top of other transitions can get tricky. But know that I know about these issues I'm glad I spent the extra time. Since Tweeny uses the Playhead API, it supports stop, rewind, play, playbackward etc, it's not really different than keeping an mp3 or swf around.
So far it's about 10K, so 3x larger than say Tweenlite, but much of that is the inclusion of the framework/Cogs is useful for many other things, websites and games especially, and I'm still working on it.
The morning had an epiphany and I was able to tie together many of the related ideas into a cohesive model, so I have a roadmap for the next few months, and even a relatively simple Authoring UI for all the features exposed. Looking at the one pager of noteobook, probably 7 boxes, and only a few UI elements, in that largely what I'm working on is creating much of the same metaphors (e.g. timeline) of Flash inside of Flash...just like Web 2.0 is largely recreating the OS inside of the WebBrowser. And Virtualization is recreating the connectivity of electronics. One that note, if your looking for good book on self-referentiality check out Gödel, Escher, Bach .