At the moment I build an application that loads our noob3D-Library dynamically. While developing I need syntax completion, to do fast coding without having to read the docs again and again
For a normal project it would just be fine to include the lib into your SWF, but I want to load it seperately. To get mxmlc to “exclude” the noob3D-Library from my SWF, I can use the “external-library-path” compiler argument (in my case it’s a custom-flex-config.xml).
This works just fine and the noob3D-Library isn’t linked to my SWF. But this is where my journey begun on yesterday evening: If I use the “external-library-path” argument with mxmlc, also the Flex framework isn’t linked to the SWF anymore. I don’t know if this is a bug or if someone at Adobe smoked too much of whatever kind of plants grow in California

You might probably also got the nice Error message “VerifyError: Error #1014: Class IFlexAsset could not be found” or something similar in your language. This is what I got. I tried lots of things to “re-include” these Flex files, but nothing worked for me.
Somewhere during my research, I found out that you can also use the Embed tag on classes, rather than variables or consts. I read this concerning Font embedding, but it was mentioned that you can only embed one Font in one class with this. Since this was not what I wanted, I closed the page and continued searching.

However, I finally tried the solution to use Embed in another way
You may know how to use the Embed tag with consts and vars, like this

public final class GeneralCursor
{
    [Embed(source=''D:/Morpheus/src/assets/AwesayCursorArrow.png')]
    private static const AWESAY_CURSOR_ARROW_DATA:Class;
[...]

This includes the specified file as a Symbol into the SWF and works just fine for most of us. But this way uses the Flex framework. If you explore your SWF with your favorite tool of choice, you might see that classes like IFlexAsset, BitmapAsset, ByteArrayAsset, NameUtil, etc. are included in your SWF. But this is not the case if you use “external-library-path”, as I already mentioned above. So, now you may know why I was talking about smoking

OK, what we can do instead is embedding our Symbols, Fonts, Bitmaps, XMLs, or any other data without using the Flex framework at all. It’s pretty simple!
For every file you want to include, you’ll have to create an own class. This class must inherit from the type of file you want to embed. For embedding Pictures, the class should inherit from Bitmap, if you want to include binary data, it should inherit from ByteArray.
Please NOTE: You can’t include XMLs as a subclass of XML, because the compiler isn’t able to transcode this. See the example code below.

Embedding XML files:

package com.badnoob.awesay.morpheus.embeds 
{
    import flash.utils.ByteArray;
 
    [Embed(source='D:/Morpheus/src/assets/xml/i18n/de-DE.xml', mimeType='application/octet-stream')]
    public final class FailSafeLanguageData extends ByteArray 
    {
        public function FailSafeLanguageData():void {}	
    }
}

Embedding Pictures:

package com.badnoob.awesay.morpheus.embeds
{
    import flash.display.Bitmap;
 
    [Embed(source='D:/Morpheus/src/assets/AwesayCursorArrow.png')]
    public final class AwesayGeneralCursorData extends Bitmap 
    {
        public function AwesayGeneralCursorData():void {}	
    }
}

Using XML data:

package foo
{
    import com.badnoob.awesay.morpheus.embeds.FailSafeLanguageData;
 
    import flash.utils.ByteArray
 
    public class EmdeddedXMLLoader
    {
        public static function loadEmbeddedXMLData():XML
        {
            var baFileData  :ByteArray = new FailSafeLanguageData,
                strFileData :String    = objFileData.readUTFBytes(objFileData.length);
 
            return XML(strFileData);
        }
    }
}

Using Pictures:

package foo
{
    import com.badnoob.awesay.morpheus.embeds.AwesayGeneralCursorData;
 
    public class EmbeddedPictureLoader
    {
        public static function loadEmbeddedPicture():Bitmap
        {
            return new AwesayGeneralCursorData;
        }
    }
}

I hope this helps!

I also tried this with XML.hasOwnProperty, what didn’t work for me. I got runtime errors, but no compilation errors. the used variable was always null.
this is the code I used:

[...]
var funcHasOwnProperty:Function = xmlFileData.hasOwnProperty;
[...]

as one would expect, this should be working without any problems. but you’re wrong, because funcHasOwnProperty will always be null. don’t ask me why and what adobe thought when designing this. maybe I should report a bug…

I still didn’t want to call the “findproperty” OP-Code for every XMLNode and every XMLAttribute, so I tried different things like coerce via

[...]
var funcHasOwnProperty:Function = (xmlFileData.hasOwnProperty as Function);
[...]

but that also didn’t work.
please note: if you call “xmlFileData.hasOwnProperty(‘foo’)” directly, everything is fine, but it seems that you can’t save it to a local variable.

finally, after different approaches, I found the solution by first coercing xmlFileData to Object

[...]
var funcHasOwnProperty:Function = (xmlFileData as Object).hasOwnProperty;
[...]

this is crazy, isn’t it?
this workaround may also work for other fields of application, but I didn’t test it yet.

My first problem with this was that my TextInputField didn’t receive any of these events, so I double checked the listeners, but everything was fine. After some research I found out that I need to set stage.focus to the current TextInputField. I thought it should be easy by just doing

this.stage.focus = this;

The TextInputField still didn’t receive any events though…
So I traced the actual value of stage.focus after setting and I got “null” in my trace. Just wonderful…
After some more research, I actually found a solution at stackoverflow.com.
What you need to do to keep stage.focus on your InteractiveObject is to listen for the FocusEvent.FOCUS_OUT event and reset the stage.focus property.
Finally I got the copy and paste functionality to work as expected by first setting stage.focus to this and then listen for the focusOut event to reset it once:

[ ... ]
private function setStageFocus():void
{
  this.addEventListener(FocusEvent.FOCUS_OUT, this.focusOutHandler);
  this.stage.focus = this;
}
 
 
private function focusOutHandler(evt:FocusEvent):void
{
  this.removeEventListener(FocusEvent.FOCUS_OUT, this.focusOutHandler);
  this.stage.focus = this;
}
 
[ ... ]

noobFuscator Download

You need an AdobeID (free Adobe Account).
It’s a 14 day Try and Buy offer.

Find a Roadmap and Feature overview on our blog.badnoob.com

Reviews, opinions and feature request are welcome!

Since the moste ActionScripting is done for the Flash Player rather than other applications, we need to keep track of speed. The AVM itself can be very very fast. What’s slowing down there is the FP (my very own experience).

So, OK you want to use get/set because of good OOP or the advanced ASDoc functionality for it – that’s fine! But don’t tell me your code is slow! NAARP…

I really wanted to know, if there are any losings in performance when using getters and setters instead of public variables, or the other way around.
Yes, there are losings! In my tests, reading public variables was almost 3 times faster than doing the same with getter-methods. But writing a public variable was more than 4 times faster than writing via setter. I didn’t think that it would be that huge difference…

So my best practices for using getters/setters:
Use getters only if
1. Your getter returns more than only the requested value, e. g. you have a getter to read the full name and it will give you a String of firstName +’ ‘+ lastName.
2. You want a property to be read-only (only makes sense, if you’re creating an API for other developers, because you should know your own code ).

Use setters only if
1. You want to validate the given value.
2. When a property is changed, something else needs to be changed too, e. g. you change the labelString of a button, so the TextField’s text of that button should change accordingly.

You may want to download my test-case and share your results: BenchmarkTests

http://www.codinghorror.com/blog/2007/02/why-cant-programmers-program.html

http://www.lightwave3d.com

So what is this guy talking all about?
There’s still a drawTriangles-method in Molehill, but as you will have expected, it’s not as easy as the old one. As a matter of fact, there will only be a few calculations that will have to be done inside AS3, like building trees if you like them. All calculations concerning transformation, rotation, scaling, etc. is performed directly in the graphics hardware.
I thought they built a big wrapper around everything, so you’d only have a few options, but my thoughts were fortunately wrong. You have all the controls over the graphics device that a C++-Developer has (or nearly). The object-data won’t be saved in Flash’s memory, ’cause everything is being hold in the graphic cards RAM.
To actually work with the Molehill API, you’ll have to write Assembler-Code. Yes, that’s what I wrote: Assembler-Code. Some of you might have seen those codes like

mov eax, ecx
jmp 0x475927

If you want to learn this, you’ll probably figure out that it’s not as difficult as it seems to be. The asm you write for Molehill is being compiled to byteCode, then stored as byteArray and will finally be uploaded to the graphics card via the graphics pipeline.
The API contains only 20 OP-Codes that you should be familar with. If you’ve done 3D-mathematics on your own, it should be self-explanatory.
What will be delivered to the graphics adapter is called TokenStream. Each Token inside that stream is of fixed size: 192 Bits.
It starts with the OP-Code [32 Bits], followed by the Destination [32 Bits], then followed by SourceA and SourceB, each of 64 Bits. Are you still with me? If you answered no, just forget about reading any further…

Do you like matrices? I hate them! However, most engines use them and the API has a native OP-Code to do matrix transformations. There are m44, m34 and m33. These are OP-Codes used for matrices 4×4, 3×4 or 3×3.
Let’s say we wan’t to transform mtx2 onto mtx1 and we want to save the equation in output. What we need to do is just simply write Assembler-Code:

m44 output, mtx1, mtx2

Quite simple, eh?
I think about all the possibilities with this API. I’ll have to do a lot of benchmarking when I’ve access to the API. I don’t have any answer from Adobe yet, but even if the alternativa-people have a big head-start, we will be able to get close to them, also if we have to wait for the beta. With the new API, it’s sooo easy and fast to create an engine, I just can’t believe it You might think different.

The manner in which objects are hold in the graphics card is totally different than that of every 3D-Engine, including noob3D. I know this hierarchy:
Object -> faceList -> Face -> vertices
so every face has it’s own vertices directly in that class. the graphics hardware just has a buffer with all vertices in it. if you want to know a vertex, you’ll have to know it’s index position.

The readers that have not closed the page yet, may be interested in the session by Sebastian Marketsmueller:

Still wanna put your hands on it? Questions and discussion are welcome.

More information will be made public here, when I’ve seen the other movies. They will also be available at bytearray.org. Maybe Thibault writes some more info on this.