But to do that, I needed a “world” normal map of the 3d object. The problem was that standard 3d normal mapping is done with local maps (img 3). I’m sure someone familiar with 3D modeling programs can create world normal maps, but I don’t, I tried for hours

So I had to create the world map in Flash and unwrap the hole thing to the local map’s UV cords. Then I used Pixel Bender to create one map by adding the local and the world map together. So I ended up with 2 maps, the diffuse map (img 2) and the world normal map (with the details of the local map). All that was left to do was render the two on top of each other and apply a Pixel Bender blendmode to create the shading effect (something like this, but with Pixel Bender)

» View normal mapping experiment

Ok, all nice and stuff, but there is actually something very interesting going on (correct me if I’m wrong).
Lets say you want an object with a bitmap material and phong shading. In the classic way you have to project every normal of every vertex every frame and recalculate the the uv mapping to draw the phong layer, After that, you blend the phong and the diffuse layer.
But with the normal map, you just have to (pixel)blend 2 bitmap material renders…. I didn’t tested it yet, but it sounds a lot faster to me? + there is no extra cost for adding local normal maps.

I joined the Away3D team and this is part of the experiments for a new FP10 branch. So no source code for now. If its still is interesting after optimalization and further testing, it will be in Away3D sooner or later.
But if you have questions, your free to ask.

                          

Move your mouse horizontal and vertical over the image to see the properties change (You need FlashPlayer 10 to see it)

The filter has 3 parameters:

• dist : Distance between the centers of the circles.
• size : Ratio of the circles.
• edgeAlpha: Needed to make the edges of the circle smooth. (can be used to create radial alpha edges)

Download the filter

Source:

<languageVersion : 1.0;>
 
kernel CirclePixels
<   namespace : "be.neuroproductions";
    vendor : "Neuro Productions";
    version : 1;
    description : "circlePixels";
>
{
 
    parameter float dist
    <
        minValue: float(1);
        maxValue: float(300);
        defaultValue: float(100);
        description: "distance";
    >;
 
 parameter float size
    <
        minValue: float(0.0);
        maxValue: float(2.0);
        defaultValue: float(1.0);
        description: "size";
    >;
 parameter float edgeAlpha
    <
        minValue: float(0.0);
        maxValue: float(300.0);
        defaultValue: float(2.0);
        description: "edgeAlpha";
    >;
 
    input image4 src;
    output pixel4 dst;
 
    void evaluatePixel()
    {
        float2 inP= outCoord();
        float xPos = (floor((inP.x)/dist)*dist);
        float yPos = (floor((inP.y)/dist)*dist);
 
        float difX = inP.x -xPos;
        float difY = inP.y -yPos;
 
 
 
        float2 newP;
        newP.x =xPos;
        newP.y = yPos;
 
        float distt = distance(inP-(dist/2.0),newP);
        dst = sampleNearest(src,newP);
        float   ssize  =size* dst.a;
            if (2.0* distt/ssize> dist)
            {
                dst.a =0.0;
            }
            else if (2.0* (distt)/(ssize)>dist-edgeAlpha)
            {
                dst.a=( dist-( 2.0* (distt)/(ssize)))* dst.a/edgeAlpha ;
            }
 
 
    }
}