I use FlashDevelop and the FlexSDK so most of this is related to that usage, but you can just as easily do it with Flash using Library Symbols in lieu of the embed tag for embedding the font.

First, built a font swf:

package
{
 import flash.display.Sprite;
 import flash.text.Font;
 
 /**
  * …
  * @author Bela Korcsog
  */
 public class MainFont extends Sprite
 {
  
  [Embed(source = "../lib/metaboo.ttf",fontName="MetaRoman",mimeType="application/x-font-truetype")]
  public const FontClass:Class;
  
  public function MainFont():void {
   Font.registerFont(this.FontClass);
  }
 }
}

There’s lots of functions related to the TTF font embedding ability and you can restrict the Unicode ranges for non-roman characters using this embed:

[Embed(source="../lib/arialuni.ttf", fontFamily="ArialUni", fontStyle = "normal",advancedAntiAliasing="true", mimeType="application/x-font-truetype", unicodeRange = "U+0000-U+2019,U+0002-U+201d,U+0004-U+303f,U+0068-U+312c,U+0108-U+31bf,U+0140-U+9faf,U+21052-U+faff,U+ff01-U+ff60")]

You need to use TTF fonts for this as that’s the only format that the compiler will recognize. You can use an online tool for converting fonts to the correct format (there’s a lot of them out there but search for online font conversion tool).

In the parent swf, you’ll need to reregister the fonts for use in the main application. Although the Font Class is static, the Font symbols are not available outside of the registered ApplicationDomain for the swf requesting the Font, so this process is important to complete for the fonts to be recognized and rendered:

Here’s a snippet that will register the fonts correctly:

package
{
 import flash.display.Loader;
 import flash.display.MovieClip;
 import flash.text.Font;
 /**
  * …
  * @author Bela Korcsog
  */
 public class Main extends MovieClip
 {
  public var fontloader:Loader;
   
  public function Main():void
  {
   if (stage) init();
   else addEventListener(Event.ADDED_TO_STAGE, init);
  }
  
  private function init(e:Event = null):void {

   removeEventListener(Event.ADDED_TO_STAGE, init);
   fontloader = new Loader();
   fontloader.contentLoaderInfo.addEventListener(Event.COMPLETE, this.fontsloaded);
   fontloader.load(new URLRequest(“FONTLOADER.swf”));
  }
  
  private function fontsloaded(e:Event):void {
   e.currentTarget.loader.removeEventListener(Event.COMPLETE, this.fontsloaded);
   for each (var f:Font in Font.enumerateFonts()) {
    if (e.currentTarget.loader.content.loaderInfo.applicationDomain.hasDefinition(f.fontName))
     Font.registerFont(e.currentTarget.loader.content.loaderInfo.applicationDomain.getDefinition(f.fontName) as Class);
   }
  }
 }
}

Next you need to create some text fields to present the font values and use ‘embedFonts = true’ on the text field.

et voila.

Basically, i’ve created an image gallery with dynamic masks that contain wipes that are transitioned over the individual movieclips.

The stack is composed this way:

Container MC >

    Image MC >

        Loader MC for Loader content

        Mask Sprite (attaches to Loader MC)

        Mask MC is used to transition the effect.

In Flash 9 on PC, there’s no problem and all the wipes execute correctly.

In Flash 9 on Mac, the wipes do not function after the first wipe completes.

In Flash 10 on both platforms, the wipes function as they do on Flash 9 for Mac — which is to say they do not work correctly.

I’m working on a solution for this project which will be a workaround for Flash 9 Mac (and i’m assuming Flash 10), but I don’t like the alternative solution since it’s not as elegant as just doing it all in code and creating masks dynamically.

Needless to say, test on both platforms, and in the newest player when developing, since they don’t all behave the same.

http://www.adobe.com/cfusion/webforums/forum/messageview.cfm?forumid=72&catid=675&threadid=1367135&enterthread=y

A little more detail regarding the changes to the top level crossdomain allowing site administrators to control sub directory located crossdomains.

http://neurofuzzy.net/2008/08/27/flash-player-10-will-not-work-with-amazon-s3/

Essentially, using S3′s subdomain feature instead of bucket location (sub directory) allows you to properly control access to your data. There shouldn’t be any issues with this solution but it’s good to be aware of these changes.

Some more info for possible redirection of your domain to another site such as the subdomain on s3:

http://www.carltonbale.com/2007/09/how-to-alias-a-domain-name-or-sub-domain-to-amazon-s3/

Here’s a link to the library:

Five3D AS3 Beta (Based on 1.0 code from www.mathieu-badimon.com).

Please send me any bug notes and I’ll update the code as required. Just a note that this is a straight port — Mathieu has been working on a new version that I’m sure will include some great improvements and when it does come out I’ll pull this version of the library as redundant.

 Rails for the most part is simply a framework that exists on top of Ruby, and generally is used as exposure for data (scaffolding is the term for generating a representation of a database table with generalized methods to get and set data against it). I’m simplifying, but that’s what I do.

REST is a type of agreement between the client and server applications which denotes a common communication protocol. I’m more apt to recommend something other than REST for Flash since there are some serious shortcomings in how the flash player communicates with the server. These are very obvious once you’ve built an app.

The general methods are very appealing at first glance — a common language for common tasks is pretty, but in usage the browsers and flash need to be able to work with these new protocols (REST uses a lot of assumptions about the HTTP methods being respected and utilized by the browser, and very often this is not the case). In point, at one point the Rails app was sending back 201 success codes with returned data, but the flash player didn’t recognize this as a success method and effectively did not send the returned data to the Flex app. Switching to a 200 method on the success worked fine. Took a while to figure that out!

Another odd situation is that very often Rails RESTified uses all manner of return codes that are often not recognized by the Flash player as good codes to get, so until the flash player uses these codes correctly and as HTTP intended you’ll be doing all kinds of work arounds to wrangle the app. But it can be done, it just can’t be assumed that it’ll be seamless (the project took twice as long to finish because of these issues).

In this post I’ll add some specific examples of solutions to odd behaviours:

In rails they’ve built in a workaround to the limitation that most current browsers face with regards to GET, PUT, DELETE, and POST requests when working with a Rails application. Only two of those methods are supported (GET and POST) so the engineers of the Rails system built in an interpretation variable to enable the other methods under a standard POST command. To send a DELETE command, you use a POST with a variable named “_method” and make it equal to the type of request.

Each method has a meaning:

GET is to request data
POST is to create data
PUT is to update data
DELETE is to delete data

In Flex, to make the call you would use this method: 

var params:URLVariables = new URLVariables();
var loader:URLLoader = new URLLoader();
loader.addEventListener(Event.COMPLETE, resultHandler);
loader.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);
loader.addEventListener(HTTPStatusEvent.HTTP_STATUS,httpStatusHandler);

request.url = http://www.wabbit.ca; 

// If a data request
request.method = URLRequestMethod.GET;

// If sending data for creating a new record
request.method = URLRequestMethod.POST;

// If sending an id to delete a record
request.method = URLRequestMethod.POST;
request.data._method = “DELETE”;

// If sending an id and data to update a record
request.method = URLRequestMethod.POST;
request.data._method = “PUT”;

// add your data objects to the request.data object
request.data["item[index]“] = item[index];  // very often Rails will expect your data to populate in the form of an array and possibly other formats of the same method.

loader.load(request);

In general the HTTP headers you may receive from Rails are not your standard responses, so you’ll have to work with your Rails developer to ensure that what is being sent to Flex/Flash can be handled by the Flash player (or browser in some cases).

Also, any 20x series event is considered a ’500 server error’ event except for the base 200 event.

My contribution was mostly to complete areas of the site which were incomplete such as the client/server interactions in the Flex CMS application.

This application is one that everyone on the team should be proud of as it has become a very usable and enjoyable application to interact with. The design team on the project was very good and I do appreciate how well thought out the documentation and project scope were.

I dealt with many very talented people not the least of which was Bryan Heu, Clickbooq’s owner and President. I congratulate everyone involved and am proud to include this project in my repertoire.

Flash 10 preview (Lee Brimlow’s blog):

http://www.theflashblog.com/

C++ scripting, VOIP

Flex 4, skinning kicks out as a scriptable mxml and css combined architecture — reducing the footprint of the framework download and improving the creative options for skinning the component framework.

Flash CS4 will represent Vectors as data, inverse kinimatics, 3D on the timeline, live preview of video. Good stuff!

Buzzword was a hot item in the keynote — not sure where it’s going but anyway…

Take a look at the sample Mustang 2008 DAE (Collada) Model:

VIEW

This is built of:

• mustang.dae (model data)
• car_uv.jpg (car uv map)
• tire_uv.jpg (tire uv map)

Taking production detailed models into Papervision isn’t really possible at this time — it’s just too limited. You should consider redoing the model as a simplified shape or using a polygon reduction tool to degrade the model (very hard to accomplish as polygon reduction will often destroy the model during the process). So, sometimes it’s best to rebuild the model trying to save some of the form of the model and putting it into a simple enough package that can be used. Rely on the texturing to provide the necessary suspension of disbelief required to ‘sell’ the concept.

In the case of the above model, I rebuilt the model from scratch and kept the polygon count as low as I could.

I haven’t seen a lot of information regarding best formats etc so I thought I’d mention how I’m currently doing it. I’ve given up on ASE format for now — I can’t seem to find a working workflow; lets focus on Collada. There’s no Collada exporter for Cinema4D (my personal favourite 3D app for now) and I’ve been trying all different ways of getting a file into Blender, and have settled on 3DStudio.3ds format (which transfers the UV and texture information into Blender effectively from C4D). Blender can export to Collada 1.4.x format, which is required for Papervision, so that’s what we’ll be using Blender for (all referenced product links are at the end).

Break out the parts that require animation, and simplify all models to the most basic structures possible.

Using Bodypaint, wrap texture onto uv’s using your favourite mapping projection technique.

Export as 3ds, and import into Blender.

Export as Collada 1.4 and then you can import into papervision previewer swf to test the model.

Here’s the settings I used from Blender:

Referenced tools:

Papervision Previewer

Cinema4D

ElectricImage

Lightwave

Papervision

Papervision Flash CS3 Component set

Blender

http://www.adobe.com/support/flashplayer/downloads.html

If you develop content in Flash you should install the debug player in all your browsers. The Flash environment is great, but it doesn’t allow you to debug browser related issues easily. Every browser has it’s own idiosyncratic behaviors, and can cause all kinds of last minute headaches when deploying to a new environment.

Here’s a technote from Adobe regarding proper configuration of the player and requried files and profiling of the application in the player:

 http://www.adobe.com/cfusion/knowledgebase/index.cfm?id=tn_19323

http://www.adobe.com/devnet/flex/articles/profiler_04.html

Actionscript.org collected a number of the steps to do the setup. 

 http://www.actionscript.org/resources/articles/207/1/Trace-and-debug-ActionScript-from-your-browser/Page1.html

 With this enabled you can do away with polluting your code with special workarounds, custom trace functions, using Luminibox or Xray, and generally slowing down your flash application. In the end, when you are comfortable and ready for a release, you can just click the box ‘omit trace calls’ and you are clean and ready for release to the world.

 One last piece of great code is FlashTracer from Alessandro Crugnola — this allows you to view the trace file from a panel in Firefox — great stuff!

 I’ve worked on Java based projects (where a lot of the terms come from and implementations get their beef from) before and lead developers in very large (100,000 lines of code) projects and found that it can hinder maintenance if the framework is not flexible and easy to understand or utilize.

It also can hinder a project with shorter time lines to push these types of code libraries to mixed groups, as some of these types of systems are geared more to one type of application or another or specifically an application vs. a media project.

With all the different options, you end up with concessions instead of building a custom solution to the project at hand. Very often these are overtly complex and in larger groups can be time consuming to implement, the exact reverse to what frameworks promote as a benefit.

Here’s some frameworks that exist for Flash that you could consider if so inclined:

CASA Framework (http://casaframework.org/)

ARP Framework (http://osflash.org/projects/arp)

Jumpship Framework (http://osflash.org/projects/jumpship)

Vegas Framework (http://code.google.com/p/vegas/)

Pixlib Framework (http://osflash.org/projects/pixlib)

These are all good but very different in their approach. I would like others to recommend other frameworks and personal experience with projects executed utilizing a framework. I’m leaning towards Pixlib as a good general purpose framework.

Personally, I’ve worked with homegrown as well as canned framework libraries and have had mixed success. Sometimes even the biggest project can not call for a full blown framework when a collection of classes and components would do the trick in a pinch.

In the end, I’m happiest in shorter projects when I use a broadcaster and a few handy animation libs.