To start of, we are going to create a new Flash AS3 document with 2 layers. The first layers will be called actions, and as the title suggests all of your actions will be entered on that layer. The next layer we are going to create a simple rectagle movie clip, with the instance name "myButton". This movie clip will act as our button. In this example all we are going to do is once the button is clicked we are going to go and play frame 2 of our movie. Frame 2 will contain an image.

This is what your movie Should look like so far. You will notice 2 layers with 2 frames, with actions in both of the frames. This is frame 1

The ActionScript on frame 1 should look like this.

myButton.buttonMode = true;
This code simply makes your movie clip(myButton) a button, it also ads the handcurser once the mouse is rolled over the button.

myButton.addEventListener(MouseEvent.CLICK, f_myButton_click);
This line is the event handler and the easiest way to read the line is ... we are adding an event listener to the button "myButton". The event that we are listening for is a MouseEvent and the .CLICK represents that the event that we are listening for is a mouse click. Once the button has been clicked we are then going to go and run function f_myButton_click. Now if you are unsure of what functions are... think if it as blocks of code which are executed only when called. Note that you can name your functions whatever you want as long as they are not already taken by flash. I personally always start my functions with f_

function f_myButton_click (evt:MouseEvent) : void {
gotoAndPlay (2);
}
This next line is the actual function f_myButton_click. Functions always begin with the word function which is followed by the function name (again, it can be anything). The next part identifies what action is actually triggering the function, in this case it is a MouseEvent. The :void part simply says that there is no value being returned to flash. The function executes the code gotoAndPlay (2)... which says go and play frame 2. If you are using frame labels you can replace (2) with ("framelabel").

stop();
This stops the movie at the current frame. And that is all the code for frame 1

And this is frame 2. As you can see it just has an image on the timeline.

Frame 2 consists of an image on the stage and in the actions layers there is only
stop();
Again this is saying stop the movie here. If you did not write the stop(); statement you movie will simply loop between frame 1 and frame 2. (As you probably know already).

You can download the source code here
EventSample

Good Luck.

Now the problem is when you try to compile the external swf file with any reference to the main timeline using parent.parent or loader.parent etc. it gives error in compilation time due to the behaviour of concrete classes i.e. MovieClip, Sprite, DisplayObject so how to make a call on parent timeline where there is no direct reference. Following is one of the approach i have found quickly. It is a tricky way to do this. What you need to do is typecast the parent of loader as an Object which is a dynamic class and then call the method which gets compiled without any error. Following is the statement for the same
if(this.parent.parent != null){
var parentObj:Object = this.parent.parent as Object;
parentObj.traceMe()
}

You can download the sample files from here . Kindly let me know if you found any other approach

Image tunnel:

Vortex of Neon PerlinNoise:

Vortex of smoking pixels:

(SmokingPixels in 2D and source. yes, probably nothing you haven't already seen in all the particle-demos around the net, just that the 3D-effect adds so much to it)

Sources for class 'Tunnel' and TunnelDemo. As a principle it's a cone and we're taking a look inside of it, bended by adding a polynome to x,y-coords. As a 3D model it's a relatively simple with no actual need for sorting the faces in z-direction, so it runs pretty fast and smoothly - I think.

Edit - September 2nd: Tunnel.as updated with usage of PerspectiveProjection and Utils3D.projectVectors - although the maths for projection in the earlier version were as simple as x2 = x*radius/z; y2 = y*radius/z; .

Anyways… while we are waiting for true reflection to find its way into our midst, here is a small implementation resembling a helper class that does the job nicely.

Download source here

/**

* Copyright(c) 2008 HelloGroup A/S, some rights reserved.

* Your reuse is governed by the Creative Commons Attribution 3.0 Denmark License

**/

package com.hello.collections

{

    public
class TypeCompareFunction

    {

        public
var type:Class;

        public
function TypeCompareFunction( type:Class )

        {

            super();

            this.type = type;

        }

        public
function getFunction() : Function

        {

            return compare;

        }

        private
function compare( item:Object ) : Boolean

        {

            return item is type;

        }

    }

} 

An example of its use could be as below…

var collection:ArrayCollection = new ArrayCollection();

collection.filterFunction = new TypeCompareFunction( aClass ).getFunction();

// Add some items of different type.

collection.refresh();

It works with three parameters: one float3 for line equation where the picture appears sharp (coefs like in Ax+By+C=0, in the demo there's two dragable blue blocks to modify that), two scales for the blur radius, in parallel and perpendicular direction at the distance of 100 pixels from the line: try setting either one to a very low value like <2.0 for a more dynamic effect:

The current pixel bender version has some limitations in looping, I ended up using the shader in a recursive way in combination with actionscript. One single shader counts the blurring only by four sampled points: for a better quality - see parameter 'quality' in LinearBlurFilter.as- the principle is to add the same shader several times, like this.filters = [ shader1, shader2, ...] . Original image and blurrings with 4, 16 and 64 samples - with 1,2 or 3 shaders: I'm glad the efficiency increases exponentally:

an example for using code:

package {
    import LinearBlurFilter;
    import flash.events.Event;
    import flash.display.*;
    public class BlurExample extends Sprite {

        [Embed(source='someImage.jpg')] // url to any bitmap
        public var MyPhoto:Class;

        public var myPhoto:Bitmap;
        public var linearBlurFilter:LinearBlurFilter;

        public function BlurExample():void {
            var lineEquation:Array = [0.707,-0.707,-6.0];
            var uScale:Number = 10.0;
            var vScale:Number = 5.0;
            var quality:int = 3;

            linearBlurFilter = new LinearBlurFilter(	lineEquation,
                    uScale,
                    vScale,
                    quality
                    );
            //	add listener to do something when bytecode gets loaded
            linearBlurFilter.addEventListener(Event.COMPLETE, shaderLoaded);

            myPhoto = new MyPhoto();
            addChild(myPhoto);
        }

        private function shaderLoaded(e:Event):void {
            //	add filters
            myPhoto.filters = linearBlurFilter.filters;
            linearBlurFilter.removeEventListener(Event.COMPLETE, shaderLoaded);
        }
    }
}

For further information: Example in photography. The old large scale cameras had the possibilities to adjust the 'plane of sharp focus'


See also Lensbabies.

Off topic: Art of Roman Verostko.

So, I started looking into C++, and I found several IDEs which worked on my computer and were nice to use. I grabbed a copy of C++ for Dummies (Stephen Davis, 5th edition), and started reading. It is a well written book, but not without its errors, some of which are acknowledged on the author's website errata page. I have programmed in BASIC before, so some of reading I did in the early chapters was familiar to me and easy to understand. I am chugging along in the book-haven't reached graphical object oriented programming yet, but I am getting there.

The two IDEs which I liked best were Dev-C++ (Bloodshed, recommended by Davis in C++ for Dummies) and Microsoft Visual C++ Express 2008. Both have their upsides and downsides-Dev C++ seems to be a more lightweight, easy to use environment, but Visual C++ is more polished. Anyways, I am working with both of them, but primarily Dev-C++. While the last release of this software was in 2005, this doesn't seem to be a problem for me.

Some screenshots of the two:

After loading up a new Max patch I created an Object Box and scrolled through the list to find the Flashserver object type and set the port parameter to 5150 (arbitrary - even crazy! - but above 1024 to avoid collisions with OS ports). I also specified 1 connection out of a possible 256.

On the Flash side, I specified the FlashserverConnect class as the Document class and made sure that the port parameter specified in the class was also set to 5150. Here's the class:

package {

import flash.display.Sprite;
import flash.events.Event;
import flash.events.DataEvent;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.net.XMLSocket;
import flash.events.IEventDispatcher;

// FlashserverConnect must extend Sprite to serve as Document class in CS3
public class FlashserverConnect extends Sprite {

private var host:String = "localhost";
private var port:uint = 5150; // LAPD code for crazy person (!?)
private var socket:XMLSocket; // Create socket
private var val:String = "Hello from Flash"; // initial value for testing
private var header:String = "val";
private var maxData:* = header + " "+ val + ";"

public function FlashserverConnect() {

socket = new XMLSocket();
configureListeners(socket);
socket.connect(host, port);
send(maxData);
}

public function send(data:Object):void {

trace("sending "+data);
socket.send(data);
}

private function configureListeners(dispatcher:IEventDispatcher):void {

dispatcher.addEventListener(Event.CLOSE, closeHandler, false, 0, true);
dispatcher.addEventListener(Event.CONNECT, connectHandler, false, 0, true);
dispatcher.addEventListener(DataEvent.DATA, dataHandler, false, 0, true);
dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler, false, 0, true);
dispatcher.addEventListener(ProgressEvent.PROGRESS, progressHandler, false, 0, true);
}

private function closeHandler(event:Event):void {

trace(event.type + "Handler: Closed");
}

private function connectHandler(event:Event):void {

trace(event.type + "Handler: Connected");
}

private function dataHandler(event:DataEvent):void {

trace("data received" + event);
}

private function ioErrorHandler(event:IOErrorEvent):void {

trace(event.type + "Handler  " + event.text);
}

private function progressHandler(event:ProgressEvent):void {

trace("progress...");
}

}

}

The next step was to test the Flash movie and view the results in Max/MXP's output panel...

Success! Now we can get down with some serious Max Flash fun.

FLfile.copy("file:///C:/JSFL/source.fla",folder+'/Exported/'+tempName);

Also you can change the name of FLA/SWF accordingly from following lines.
tempName = "Image_0"+i+".fla";
tempName = "Image_"+i+".fla";

Following are 3 algorithms those i have converted. All these 3 are not one of the fastest however Fastest ones are in queue and will be up soon

Bubble Sort : Exchange two adjacent elements if they are out of order. Repeat until array is sorted. This is a slow algorithm.
Selection Sort : Find the largest element in the array, and put it in the proper place. Repeat until array is sorted. This is also slow.
Insertion Sort : Scan successive elements for out of order item, then insert the item in the proper place. Sort small array fast, big array very slowly.

Following is code for Bubble sort and rest you can download from here

package com.utils.Algo
{
import flash.display.Sprite;
/**
* ...
* @author Yogesh Puri
*/
public class BubbleSort extends Sprite
{
public function BubbleSort()//Bubble sort function
{
}
public function sort(_arr: Array)
{
var iLen:uint = _arr.length;
var i, j, temp: uint;
for(i=0;i<iLen;i++) {
for(j=0;j_arr[j])
{
temp =_arr[i]; //swap
_arr[i]=_arr[j];
_arr[j]=temp;
}
}
}
}
public function printElements(_arr:Array) //print array elements
{
var iLen:uint = _arr.length;
for(var i:uint=0;i<iLen;i++)
trace(_arr[i]);
}
}
}