The release notes for this version are on the Flint Particles website, along with information where to download the new version. Here’s a little demo using Away3d 4 and Stage3D.

View source code.

On top of that, Research in Motion offered free Playbooks to any developer who had an app accepted into the App World store before the launch of the device – who could resist. So I built an app.

I was in the fortunate position of having a lot of existing code I could use, and I decided to create a particle effects toy using Flint. The result is Particle Soup. It’s small, self contained and a great showcase for Flint. I hope you enjoy the results.

I started work on Flint Particles before Flash 10 was launched, so back then I created my own 3D mathematics classes for Flint. At the time this was not unusual – Away3D and Papervision3D had their own Number3D and Matrix3D classes, for example.

Since the release of Flash 10, open-source projects have gradually switched to use the native Vector3D and Matrix3D classes found in the flash.geom package and recently I decided it was time for Flint to also make this change, hence the release of Flint 3.0 a few weeks ago which uses those native 3D math classes.

Converting Flint to use the native classes was an interesting experience. For one thing, I think the architecture of Flint’s classes was better than the native classes. That wasn’t sufficient reason to stick with Flint’s own classes; using it’s own 3D math classes was a barrier to entry for users who were familiar with the native classes and resulted in many questions from confused new users. (For much the same reason, I don’t use the excellent As3-Signals library by Robert Penner in Flint, even though I use it in all my other work.)

So I set about converting Flint to use the native 3D classes. The initial conversion was mostly straightforward, only complicated by a lack of functionality in the native classes that sometimes meant one line of code using Flint’s classes had to be replaced with 3 or 4 lines of code using the native classes.

Having made the change, however, I was surprised to find two significant issues with the new code. The first was a couple of bugs in the native classes, which were not too serious since I could find a way to work around them. The second, and far more troubling issue, was a very large drop in performance – the code using the native 3D classes ran at about one quarter of the rate of the code using Flint’s own 3D classes.

I was eventually able to fix the performance loss, mostly by inlining some critical and slow methods including, for example, the code to transform every particle’s position from global coordinate space to camera coordinate space, where instead of a simple

pp = camera.transform.transformVector( p );

Flint now does

var raw:Vector. = camera.transform.rawData;
pp.x = raw[0] * p.x + raw[4] * p.y + raw[8] * p.z + raw[12] * p.w;
pp.y = raw[1] * p.x + raw[5] * p.y + raw[9] * p.z + raw[13] * p.w;
pp.z = raw[2] * p.x + raw[6] * p.y + raw[10] * p.z + raw[14] * p.w;
pp.w = raw[3] * p.x + raw[7] * p.y + raw[11] * p.z + raw[15] * p.w;

for a massive performance improvement.

Coral

In light of the issues I encountered I have decided to release the 3D math classes that were formerly part of Flint as a separate open source project. I continue to use these classes in my own work (with the exception of Flint) and others may want to do so too.

I am calling the project “Coral” – apparently small pieces of coral are sometimes found inside larger pieces of flint. Coral is available on Github, including unit tests and performance tests. Please feel free to use it, fork it and improve it.

Since releasing Flint 3.0, I modified the unit tests and performance tests in Coral to also apply to the native 3D math classes, Vector3D and Matrix3D. This was out of curiosity mainly, but it revealed a number of bugs in the native classes and where the major performance weaknesses in these classes are.

In the following posts I’ll look at the results of these tests, with posts about the bugs I found and a performance comparison of Coral and the native classes. But first, if you’ll indulge me, here’s a post comparing the architecture of Coral and the architecture of Flash’s native 3D classes.

Re-architecting the designer-developer workflow

My first session is an update to my session on Smart Components from 360|Flex San Jose. I’ll be talking about where my idea of smart components came from, how the architecture has developed and evolved, and how it enables us at BrightTALK to decouple the developers from the client project development cycle, completely changing the relationship between designers and developers.

Of course, there will be code and examples, and I’ll also show how to use Robotlegs or Swiz as the basis for your smart components architecture.

Open source is for life, not just for Christmas

This presentation is about my experiences developing and managing the Flint Particles open source project. After small contributions to other open source projects, Flint was my first venture into developing and managing an open source project myself. I’ve been managing the project for nearly 3 years now and I’ve learnt a lot along the way, about programming, marketing and open source, and also about people, their motivations and their failings, myself included.

I’ll discuss why I started the project, the highs and lows during the past three years, what my expectations were and how the results far exceeded those expectations. I’ll talk about the people I met, and the lessons I learnt. I’ll also tell you my seven steps for getting an open-source project off the ground, and I’ll tell you the one thing you must never, ever, ever do if you manage an open-source project. Unless, of course, you want that project to die.

This session is quite a departure or me. Previous sessions I’ve presented have been focused on code, but this one is about experiences. There’s no code to hide behind. The contents are stories and anecdotes, some of them painfully honest, others painfully funny. Hopefully the audience will laugh in the right places.

DC here we come

I’m really looking forward to this 360|Flex. There’s so much going on.

• An amazing bunch of speakers with over 40 presentations on a diverse range of topics.
• Workshops on Flex 4, Air for Android, Robotlegs, Push-button engine, Litl and more.
• Lots of great developers to chat to, including many of the Adobe Flex team.
• Great evening events, like the 360Flexapalooza.
• The charity code jam – what a great idea.

If you’re a developer and you can get to DC, come and join us.

Here’s a simple example of these collisions in action

View the source

Full details of what is new in this version are on the Flint website.

View the source.

Full details of what’s new in this version are on the Flint website.

Also on the site and in the downloads is a new example using the new renderers to create grass. The result looks like this.

View the source.

The grass will look different every time. I have deliberately made this draw slowly so the effect can be seen. It could be rendered much more rapidly by adjusting the parameters. The grass could also be draw instantaneously as a static image by using the runAhead method of the emitter to jump straight to the end state of the system.

Have fun with the new version.

This means that all Flint’s renderer’s have Flex Framework compatible counterparts that extend UIComponent and that particle effects can be created with MXML code.

So, for example, a snow effect can be created like this

<?xml version="1.0" encoding="utf-8"?>
<mx:Application
  xmlns:mx="http://www.adobe.com/2006/mxml"
  xmlns:f="http://flintparticles.org/2009/flint2d"
  layout="absolute" width="600" height="400">
  
  <mx:Script>
    <![CDATA[
      import org.flintparticles.common.displayObjects.RadialDot;
    ]]>
  </mx:Script>

<mx:Image source="@Embed(source='assets/Snow_1.png')"/>
<f:DisplayObjectRenderer id="renderer" width="600" height="400">
  <f:emitters>
    <f:Emitter id="emitter" autoStart="true" runAheadTime="10">
      <f:counter>
        <f:Steady rate="150"/>
      </f:counter>
      <f:initializers>
        <f:Position>
          <f:LineZone startX="-5" startY="-5" endX="605" endY="-5"/>
        </f:Position>
        <f:Velocity>
          <f:PointZone x="0" y="65"/>
        </f:Velocity>
        <f:ImageClass imageClass="{RadialDot}" parameters="{[2]}"/>
        <f:ScaleImageInit minScale="0.75" maxScale="2"/>
      </f:initializers>
      <f:actions>
        <f:Move/>
        <f:DeathZone zoneIsSafe="true">
          <f:RectangleZone left="-10" right="620"
                   top="-10" bottom="420"/>
        </f:DeathZone>
        <f:RandomDrift driftX="20" driftY="20"/>
      </f:actions>
    </f:Emitter>
  </f:emitters>
</f:DisplayObjectRenderer>
<mx:Image source="@Embed(source='assets/Snow_1_over.png')"/>
</mx:Application>

Which produces this swf

All the examples in the Flint project are now available in at least three forms – Flash, PureAS3, and Flex.

Have fun with the new version.

I’ll be taking a short break from Flint while I catch up on some other work, then I plan to push the 3D features further, with better integration with Away3D and Papervision3D and the addition of support for Sandy.

Here’s an example of the new version of Flint doing flocking in 3D.

For Away3D Flint has one renderer, the Away3D renderer, that uses any Away3D Object3D type for displaying each particle inside an ObjectContainer3D. This lets you use 2D sprites or 3D objects for the particles.

For Papervision3D, Flint has three renderers -

• A pixel renderer that displays each particle as a pixel in a Papervision Pixels object.
• A particle renderer that displays each particle in a Papervision Particles object using a Papervision particle.
• A basic renderer that displays each particle in a DisplayObject3DContainer using a Papervision DisplayObject3D object.

In all cases, the renderer sets the appropriate properties of the particle’s display object based on the state of the particle system and leaves the 3D engine to do the drawing.

Flint can be downloaded from the Google Code repository. Along with the source download, you’ll find documentation and examples using the new features.

Have fun with this, and if you find any bugs or spot a better way to do something please let me know via the Flint forum.