i took his class and kicked it up a notch. now it's able to take any DisplayObject as a source and lets you use it as an icon for flex components:

of course it works in MXML, too:

i've also added a third parameter for animated DisplayObjects like Video or MovieClip - added this just for fun, it will definitely cost some performance to display animated stuff and may be buggy.

thanks again to ben for the previous work, it really is some smart way to bypass adobe's way of only using classes

here it is: IconUtilityPlus.as

edit: fixed drawing method for DisplayObjects with offsets <0

i wish i had the time to play around with it some more by now - months have passed! :/

remember to get a status account and put your id in the sources - otherwise it won't work. have fun.

according to the example of the first part of this article we would now like to pass our receiverFunction() an instance of SomeObject instead of a String.

setup

here's the initial class SomeObject which we'll try to send from one peer to another:

of course we have to adjust our peers as well:

sending peer:

the timer-function sends an instance of SomeObject with a random value every second through the stream.

receiving peer:

we want the receiver to accept the object and trace its value in the console.

unfortunately the application in its current state would throw an AsyncErrorEvent caused by the fact that the receiver is not able to read a SomeObject from the stream, it only sees a strange Object of unknown type:
Type Coercion failed: cannot convert Object@3019da9 to SomeObject.

maybe you know this error from experiments with ByteArray. in fact there is quite a sum of analogies between the ByteArray-methods writeObject() and readObject() and the exchange of data via NetStream.send() - that's because both are data streams.
so we have to make our SomeObject serializable, means: if we can write it to a ByteArray and read back again, we're halfway there.

i think i'll put a jump here, because this may be getting a longer article

serialize it

first of all our class has to implement the interface IExternalizable, the language reference tells us why:

The IExternalizable interface provides control over serialization of a class as it is encoded into a data stream. The writeExternal() and readExternal() methods of the IExternalizable interface are implemented by a class to allow customization of the contents and format of the data stream (but not the classname or type) for an object and its supertypes. Each individual class must serialize and reconstruct the state of its instances.

so we have to find a way to break our SomeObject down to its pieces. fortunately the load of our class is only one integer, so the readExternal() and writeExternal() implementations would look something like this:

when an instance of SomeObject is written to a data stream, it "manually" writes the load, i, to the output-stream.
and when you try to read the instance from an input-stream, it "manually" reconstructs the object by creating a blank object and filling it with the load.
(those streams i'm talking about can be one of the following: ByteArray, LocalConnection, SharedObject, NetConnection and in our case NetStream!)

note! this blank object is an instance created with no parameters, like new SomeObject(), that is why we have to put a standard-constructor in place of the one expecting the value parameter:

so that's it? ha! of course not. i think adobe should really add this piece of information to the api of IExternalizable, because without it the readExternal() and writeExternal() methods are nice and all - but the serialization just won't work.
we need to register the class for AMF encoding (which i called 'serialization' until now and from here on again), the flash.net package supplies the function for that: registerClassAlias()!

a nifty way to do this for our class is with a static constant. with a static constant we can have the function call to registerCallAlias() only once for all our instances, even though it returns nothing:

ok, now we're nearly set. our class is now ready to be written to and read from a data stream, e.g. ByteArray:

this is a good and fast way to test if the serialization and reconstruction of your class works without taking the long route through the internet and back again via NetStream

stupidity

the local serialization works. the remote however does NOT:
ArgumentError: Error #2173: Unable to read object in stream. The class SomeObject does not implement flash.utils.IExternalizable but is aliased to an externalizable class.

why? i dont really know the answer (maybe you do?), but i know the solution:
we have to (trash-)instantiate the class once on the receiver's side. on the receiving NetStream's client-object to be exactly.

what? yeah right. here is the way how to do this for our clientObj we used above:

you could also write a new class and use it as the NetStream's client-object:

and finally, DONE! now the peers can exchange instances of SomeObject without any strange errors.

here's the now complete and working SomeObject-implementation:

conclusion

i know it sounds like a lot to do, but essentially you just have to:

• implement IExternalizable
• register the class for serialization with registerClassAlias()
• instantiate the class on the receiver's client once

just remember always to break everything down to serializable types and provide a way to put it back together again.

i hope you guys come up with some cool ways to use this!

since i am supposed to work on my bachelor thesis it got quiet around here.
but when i read about the new stratus service a few days ago i couldn't wait to get my hands on it. for those who haven't heard of it: it's a service which provides information to the flash player/air instance to communicate peer-to-peer to another remote instance. before this stratus beta started there was no way of using the new rtmfp (an udp-based network protocol which came with fp10) at all.

after creating a small one-way microphone-chat i wondered how to exchange arbitrary data between the peers. the adobe stratus site reads about the use of rtmfp: "A video chat application, Multi-player game, Voice Over IP" - ok, so while the first and last of that list is in fact quite the same (NetStream.attachCamera() and attachAudio()) and greatly covered by jozsef vass' article "Stratus service for developing end-to-end applications using RTMFP in Flash Player",  there are no resources about how to exchange data other than video and audio. or are there?!

in the fp10 api i stumbled upon NetStream.send() which was previously used to communicate with the FMS only, i guess. so like with ExternalInterface you can call functions outside of flash's sandbox: so not javascript this time, but actionscript on other peers. (:
to be more specific: you call functions on the NetStream.client which is of type Object - so you can put there whatever you want. to a function of this client-object you can pass as many arguments as you like, as long as they are of native types.

you'll find a short example after the jump:

the premise of this example is an established rtmfp-NetConnection (how to do so you can read in vass' article linked above):

on the sending peer:

var netStream:NetStream = new NetStream(netConnection, NetStream.DIRECT_CONNECTIONS);
netStream.send("receiverFunction", "foo");

on the receiving peer:

var netStream:NetStream = new NetStream(nc, id_of_sending_peer);
var clientObj:Object = new Object();
clientObj.receiverFunction = function(arg1:String):void{ trace(arg1); }
netStream.client = clientObj;

so every time the sender's NetStream calls send("receiverFunction", ...) the receiving peer outputs the incoming argument in the console.
but that works for native types and objects only. that reduces the communication to only Booleans, ints, Numbers, Strings, Vectors and Arrays (and the others i have forgotten).

in the second part of this article i'll show you how to send objects of your custom classes back and forth between the peers.

the finetuning took a while so that there are no more hickups and noises when changing the pitch fluently as you can hear in the provided example.
well, at least i think so. it's only been tested with my local beta standalone player yet. the release version is out since yesterday or so and the bad news already spread - there are again changes to the sound api causing huge latencies depending on your operating system and your hardware apparently.

whatever. be sure to get the fresh flash 10 player - no more beta - and check out the little turntable.

the new SoundPitch class is to really easy-to-use: it extends the regular Sound class and the access works just the same:

• load a sound via .load(myURLRequest) or .load(mySoundObject)
• play the sound via .play()
• pitch the sound via .pitch = 0.7
• you can also change the buffer's length via .bufferLength = 6

get it here! (going to clean the code up soon

just play around a bit with it. for instance, you can change the position of the point the ripples "look at" and of course the position of the light source.
if your eye isn't too critical - regarding the straight circle outline shape of the whole thing - it's pretty neat i think

and again i encourage you to install the newest beta player of flash 10.
i thought about adding another link to a projector-executable because the flash 10 player plugin hasn't really spread that widely yet. on the other hand it is kind of strange to download a 2.x mb executable just to see a effect designed to run in a browser ;D

the elegance of a sphere is that it looks exactly the same from whereever you look. now with the transformed surface this effect is gone - it looks alot flatter than the spheres. also it wouldn't make sense to have a few of them floating around in space as they do in the previous post.

maybe in a later post i'll go into detail of how it all works. but i have another approach in the oven i'd like to finish first

• ambient illumination (as a substitute for all indirect light bouncing around in the scene)
• diffuse illumination (lets parts of the surface pointing to the light source be lighter than those pointing somewhere else)
• specular illumination (adds highlights - you can simulate different materials with that by playing around with the parameters)

that's phong. its all that gets calculated for each pixel. and that's a lot.. you can see that pretty soon as you add spheres.
even with a multicore cpu (which is finally supported by flash player 10, yay!) you're happy to reach a bit over 30 spheres without heavy frame drops.

well. of course a shader isnt the best way to render a sphere because you could do lots of stuff iteratively using the previous calculations. that's a thing you cannot do with pixel bender at all - you don't know in which order the shader runs through the image.
but that is another topic

the current release of flash 10 is needed for this and further examples!

greetings fellow flash(develop)ers!

finally i got myself to posting a first entry on my blok.

not only that its the first post here - it's also the first content on krisrok.de! i hope you enjoy my little experiments and stuff which will pop up here soon.

ah i should drop some lines to introduce myself to you: currently i’m a 24 year old flash developer working for a middle sized, cozy agency in duesseldorf, germany. my main interests are the features of the upcoming flash cs4, especially pixel bender at the moment. so much for now - you’ll read more about that soon enough ]]> http://krisrok.de/blok/?feed=rss2&p=3