Coincidentally, I’ve been working on a very similar problem. I have a game prototype that procedurally generates its own (quite large) texture and normal maps. Even on modern machines that can take a few seconds, during which time the Flash player becomes completely unresponsive. That’s a little inconvenient, but in doing some recent public testing it seems that some browser and OS combinations will crash during that unresponsive period, which makes it a serious problem. edit I’ve since discovered that it wasn’t the Flash player locking up that caused the crash, but my trying to run shaders on overly large images. Still good practice to not lock up the Flash player though!

To avoid the Flash player becoming unresponsive, I have split the heavy processing into many smaller chunks with their execution split between frames (not using any shader stuff for that, just plain old actionscript.) I found a quite detailed article about this approach which probably explains it better than I can.

That said, I’m still getting some reported crashes. I’ve chopped up the processing into even finer chunks for a future version so hopefully that’ll finally fix it.

To actually answer your question: It should be possible to keep Flash being responsive whilst also doing heavy parsing, but you’ll need to rearrange your code a little so that the parsing operation can be split between multiple frames. Shaders will probably not be much use in this case (if you were doing just heavy number crunching it would be possible to do that crunching on an asynchronous shader which would be neat.)

“It is possible to run a shader asynchronously which will free it completely from the actionscript thread, and allow the actionscript to keep executing at the same time.”

That makes sense to me, and I’ve messed around with it. But I’m starting to think that what I want to do isn’t what shaders are designed to do. Basically, I want to make a spinning progress indicator that won’t stick when I ask flash to parse, for example, a giant xml file.

But it seems that once ‘evaluatePixel’ has evaluated all of the pixels in its target, it’s done and you can only re-invoke it by changing a parameter, which is usually done on an enter frame basis. So, you can’t really start the pixel bender, let it run without touching it for a while and then stop it. As I see it, that’s what you’d need to do to make a Shader-based preloader that didn’t rely on the framerate of your swf and would never stick no matter what the actionscript thread was doing.

Does that make sense? Can you think of a way to achieve it?

Thanks!

I’ve varied between a few methods for applying what I refer to as the “light map” to the unlit image. The light map is an image that represents how each pixel is illuminated: black for no illumination, white for full illumination. In the above example the light map is greyscale as it’s using just a single white light source, but it could have varied colours.

Using Flash’s built-in BlendMode.HARDLIGHT works quite well, although you may want to lower the brightness of the light map first to stop the result being blindingly white in places.

In the example here I think I am just multiplying the colours. I do it in another custom shader to let me adjust the calculation so that a 0x7f7f7f pixel on the lightmap will result in no change to the base image.

Nvidia’s normal map plugin for Photoshop (just google “nvidia normal map plugin”) is also quite useful for creating normal maps.

I think much of the effect is due to using a photographically generated normal map (although it does also cause some slight artefacts where there were shadows in the photo.)

Here is the source for the shader in Pixel Bender to produce a “light map”, which is layered over the original unlit image to create the full effect.

<languageVersion : 1.0;>

kernel NormalMapper
<
    namespace : "";
    vendor : "Salt";
    version : 1;
    description : "Produces a light map based on a light source's position and a given normal map.";
>
{
    input image4 normalMap;
    output pixel4 result;

    parameter float3 lightPosition
    <
        minValue: float3(-500.0, -500.0, 0.0);
        maxValue: float3(+500.0, +500.0, 200.0);
        defaultValue: float3(60.0, 60.0, 60.0);
    >;

    parameter float3 lightColour
    <
        minValue: float3(0.0, 0.0, 0.0);
        maxValue: float3(1.0, 1.0, 1.0);
        defaultValue: float3(1.0, 1.0, 1.0);
    >;

    void
    evaluatePixel()
    {
        float2 positionHere = outCoord();

        float3 toLight = lightPosition;
        toLight.xy -= positionHere.xy;
        toLight = normalize(toLight);

        float4 normal = sampleNearest(normalMap, positionHere);
        float3 normalVector = (normal.rgb * 2.0) - 1.0;

        //if you trust that your normal map is already normalised you can skip this for a performance boost:
        normalVector = normalize(normalVector);

        float normalFactor = dot(normalVector, toLight);

        result.rgb = normalFactor * lightColour.rgb;
        result.a = 1.0;
    }
}

I’ve also just posted a tutorial on how I implement shaders in Flash.