So I’m finally back at work from a week at 360|Flex, San Jose, and like the title suggests, it was great!

Tell us more!

Here’s my little blurb about the conference, in case you weren’t there:

This was my first 360 conference, and I had the honor of speaking there as well. I got to talk a bit about the Pixelwave framework, and give an overview of what a Flash developer may need to know to get started developing native iPhone apps. I also got to show a few demos of the engine in action, and finally demoed our upcoming iPhone game, a re-work of the popular Dino Run Flash game.

So that was nice, but the rest of the conference is what’s probably going to keep me coming in the years to come.

The speakers were good, the parties were fun, the location was cool, but what I probably enjoyed most were the people. I got to meet some really cool developers from all over the world, and make some really great connections. I think the smaller, more intimate atmosphere of this conference is what really sets it apart, allowing people to really spend time together, get to know each other, and build real friendships instead of just exchanging business cards. if you can make it to one of these in the future you should, and come say hi!

What about the files?

The slides

Slides360 Flex2010 Oz Michaeli

View more presentations from Spiralstorm Games.

Some code

I didn’t show too much source at the presentation, and when I did most of it was in Objective-C, using the Pixelwave framework…

There’s no sense in putting out source which depends on an unreleased framework, but rest assured that it’ll be available when the framework comes out.

The particle simulation demo had a Flash version, which I showed at the talk, so if you want to look under the hood of the effect, here it is: ParticleTest

Every once in a while we come across something in Flash authoring that doesn’t work quite right… For example not being able to select a few symbols and swapping them with a different one from the library.

We can’t blame Adobe for this though since they can’t possibly think of everything, and they gave us the means to extend Flash’s capabilities using JSFL. If you’ve never heard of it, JSFL (Java Script Flash) is a javascript API that can be used to make the Flash authoring do whatever you want programatically.

So we had the need to swap something like 30 symbols on the stage with a different one from the library, and once you select more than one symbol the little ‘Swap’ button in the properties panel gets grayed out. We could select each one and swap it individually, but that would take waay too long… So I wrote a small script to do this, and thought I might as well post it here for everyone to use.

It’s super easy to install, just double click the MassSwap.mxp file and it’ll be added to Flash’s commands list (via the extension manager).

Once you’ve installed it you can use it like so:

Even though we only officially announced the Pixelwave framework yesterday, our list of beta testers has grown tremendously in the past 24 hours.

It looks like alot of devs are a-twitter about it and I wanted to  dedicate a blog post to let everyone know that I’ll be showing off some of the framework’s capabilities at this upcoming 360|Flex conference in March as well as 360|iDev in April.

I’ve heard so many good things about these conferences that I can’t wait to get there and meet all the other like-minded people and pretty much just nerd out about code. If you’ll be there do stop by and say hi (look for Oz Michaeli), it would be nice to meet you anonymous reader.

Everyone has already heard about 360|Flex, but If you’re into iPhone development, and you’ve never been to 360|iDev you should definitely check it out.

360|iDev is like 360|Flex for iPhone developers, and one of the biggest iPhone conference for developers out there. The conferences are run by a bunch of very down-to-earth, fun loving, guys (and gals) who have been awesome so far.

What’s going on at 360|iDev :

• iDev is going to go on from April 11 – April 14 (sunday to wed) in San Jose, CA.
• Currently there are 40 sessions planned, 5 hands-on training sessions, and almost 40 speakers.
• The parties are supposed to be extra awesome (looking forward to appFigures‘), and all the curricular activities will be taking place at the Marriot (and it’s where all the speakers stay), so it’s probably the best place to book for maximum exposure. From what I understand there’ll be a special rate for conference goers: bit.ly/360idevhotel
• It looks like the early-bird tickets are gone, but if you buy your tix with this very special link you’ll be rewarded in heaven (There’s a sort of contest among the speakers for who gets the most people to go)

You can learn all about it at www.360idev.com.

And you can also find me on twitter @oztune.

Today I’m really excited to introduce something we’ve been working on for quite a while here at Spiralstorm.

It’s called Pixelwave and it’s a complete framework for building 2D games and applications on the iPhone, based completely on the Flash AS3 API.

The idea started around mid-2009 when we realized that there really weren’t any good 2D engines out there for the iPhone that wrap OpenGL ES in a clean, object orientated framework, while running in a really fast, optimized way.

We’ve also been using Flash for ages, and decided to start out by using the same class and function names used in Flash to make our lives easier.

The engine has come a really long way since, actually getting overhauled twice until we had something we’re really happy with.

Our main goals were ease-of-use and optimized rendering. The end result is an optimized C-based core, with an easy to use Objective-C interface.

The framework now replicates a lot of the core functionality of Flash in Objective-C. We chose to go with Objective-C over C or C++ because of it’s inherent similarities to Actionscript 3, at least as far as sharing the same concepts for classes/interfaces/methods in a very clean and simple API.

To keep things as fast as possible though, the engine’s core is built completely in C, and wraps OpenGL very intelligently, doing a lot of optimizations for the user for free.

So when we realized just what an awesome tool this creation has become, we decided we need to share it with the world, and open-source it for everyone!

So lets talk features. Here are the big ones:

• Super optimized OpenGL rendering. You just tell Pixelwave where to draw, it’ll take care of the rest
• Very clean API, following the Flash ActionScript 3.0 framework structure.
• Simple event dispatching model, just like Flash. Event bubbling and capture phase included.
• Handles native iPhone features with style. (ex: Listen to touch events just like you would mouse events in Flash, very intuitive)
• Native vector drawing, using the Graphics class
• TextFields with native or custom fonts.
• One line texture loading, supporting many different texture types
• Simple sound playback
• Very easy to extend the engine’s functionality (if you know OpenGL) by subclassing the DisplayObject
• Plays nice with Cocoa Touch, contained completely within a single UIView

So we know all those features are awesome for general use, but seeing as we are all about creating games we thought we’d also share our useful utility classes specialized for games. Since these aren’t a part of the core engine we grouped them into the PixelKit, a collection of classes for game makers to use with Pixelwave. It’ll all be in the same package, pre-integrated for everyone to enjoy.

Main PixelKit features:

• Resource Manager – An efficient, object-oriented resource manager that can handle any file type + sync/async loading
• Animation Importer – Turn your Flash MovieClips into PixelKit AnimationClips with the PixelKit animation importer and the Flash animation exporter (more on that below)
• Tweening engine – A must for any real app, integrated with PIxelwave
• A Particle System – An optimized particle system for use with Pixelwave
• Physics engine bindings – We like Box2D

The Flash exporting conversion tool is another, completely separate app we’ve been working on for a while. It lets you turn your Flash animations into PixelKit AnimationClips, and control them with commands like gotoAndPlay, gotoAndStop, etc. We’re going to keep this one on the down-low for now, expect more info on this in the future.

This framework shines when it comes to code. Things that would take dozens or hundreds of lines before can be achieved in only a few. Whether you’re familiar with the Flash API or not, this framework provides a clean, easy-to-learn API that just makes sense.

Creating a vector shape:

PXShape *shape = [PXShape new];
[shape.graphics lineStyle: 1];
[shape.graphics drawRect: 0 : 0 : 100 : 100];

shape.x = 50;
shape.y = 50;
shape.rotation = 45;

[self addChild: shape];
[shape release];

Loading and displaying an image:

PXTexture *smiley = [PXTexture textureWithFileName: @"smiley.png"];
[self addChild: smiley];

Listening to an event:

[self addEventListener: PX_TOUCH_EVENT_DOWN listener: PXListener(onSmileyTouch:)];

- (void) onSmileyTouch: (PXTouchEvent *)e{
    smiley.x = e.localX;
    smiley.y = e.localY;
}

If you’re a Flash developer, we also want to know what you DON’T like about Flash. Yup, we figured if we’re already getting our hands dirty we might as well fix those little nuances that drive us crazy with Flash every day. For example, in AS3 you probably find yourself writing this alot:

sprite.scaleX = sprite.scaleY = 0.5;

Well, in Pixelwave the DisplayObject has an extra, derived property called ’scale’. Changing scale modifies both the scaleX and scaleY property.

sprite.scale = 0.5;

As you can see we’ve been very busy here at the Spiralstorm offices. We’ve been developing all these tools for internal use, but we think the community can take them to places we’ve never even imagined. Everything will be open-source, I can’t wait to see what will happen.

So please, tell us what you think! We’re nearing the beta testing stage soon.
If you want to help us test all this, please contact us. We’ll keep you updated.

I, (Oz) also have the great honor of speaking at 360|Flex and 360|iDev these upcoming two months, and guess what I’ll be demoing…
If you’re going to be attending 360|Flex or 360|iDev (and you should in any case), come check it out!

We also have a new dedicated site: www.pixelwave.org

I don’t know if you noticed, but the app store was a bit screwy last week.

Reports didn’t come out for a whole day and some ranks changed significantly over very short periods of time.

appFigures dug into their infinite bag of App Store data to shed some light on this.

Check out their informative blog post here

If you’re using OpenGL, you may have a need to triangulate your polygons in order to draw them.

A common algorithm to do this is the ear clipping algorithm. We’ve been on the search for a solid implementation of this for a while, and have finally found one:

http://www.flipcode.com/archives/Efficient_Polygon_Triangulation.shtml

It’s written in c++ and has no dependencies (except for stl). It was really easy to use, and worked well in our tests.

We’ve been so busy lately that we haven’t had any time to share with the world, but have no fear, with the aid of our new, redesigned blog, we’ll finally have a venue to talk about everything Flash, iPhone, and games.

Check back in the upcoming days when we’ll be blogging about what we’ve been up to.

Sometimes in your macros you need to use a variable, but you can’t scope it to the macro. If you use this macro more than one in the same scope you get a duplicate variable warning.

For example, let’s say this is your macro:

#define LOOP_10_TIMES \
int i = 0; \
for( i = 0; i < 10; ++i)

And this is your implementation:

LOOP_10_TIMES{
	x += i;
}

This is fine, but what happens when you want to use this macro twice? Like so:

LOOP_10_TIMES
	num += i;

LOOP_10_TIMES
	mun += i;

You’re sure to get a nasty error (or at least a warning).
This is because your code now declares the variable ‘i’ twice in the same scope.

So how do we solve this? Our macro needs to create its own unique variable each time and use that instead. This is where the __LINE__ preprocessor directive comes into play

Using __Line__ you can figure out what on what line in the file the call to the macro is located. So if you combine the current line with the name of your variable you can create a unique variable which will never repeat within the same source file twice.

So how do you generate a unique variable? Use this handy code:

#define _LINENAME_CONCAT( _name_, _line_ ) _name_##_line_
#define _LINENAME(_name_, _line_) _LINENAME_CONCAT(_name_,_line_)
#define _UNIQUE_VAR(_name_) _LINENAME(_name_,__LINE__)

You’re probably wondering why this code does in 3 nested calls what it can do with just one… well if you consolidate these three lines into one it just won’t work.. try it out. This works though, I promise.

Ok so now that the hard part is over, here’s how you use it

So here’s a little usage example:

//Note the line that the code is actually on

int _UNIQUE_VAR(myVar) = 5;
int _UNIQUE_VAR(myVar) = 10;
int _UNIQUE_VAR(myVar) = 20;

//This is what the output is

print( myVar3 ); //output: 5
print( myVar4 ); //output: 10
print( myVar5 ); //output: 20

I hope that helps you, it took a while to figure out but it’s definitely useful in a sticky macro situation

Have you ever wanted to call a c function located in one file within a different c++ (.mm / .cpp) file?

If you did, you probably know that it can be a royal pain if you don’t know the trick.
So if like me you’ve been looking for the solution, it’s very easy! Just use the extern “C” keyword (not to be confused with plain extern). Here’s an example:

extern "C" #include "my_c_code.h";

This also works with the Objective-C #import keyword:

extern "C" #import "MyObjCClass.h";

or alternatively for multiple includes

extern "C" {
#include "my_c_code.h"
#include "my_other_c_code.h"
}

And that’s the way you include someone else’s C code into your C++ files. Easy!

But…
If you’re writing brand new C code and you want it to be automatically compatible with other C++ code you can build it in a way that will make it #include’able into any source file.

Using the __cplusplus preprocessor variable you can check if the current build target is a c++ file and if so, surround your code with extern “C”

So for example let’s say this is our current C header file:

//my_c_header.h:

int addOne(int n);
int globalVar;
//..etc

To make this code C++ friendly, we’d do this:

//my_cpp_friendly_c_header.h:

#ifdef __cplusplus
extern "C" {
#endif

int addOne(int n);
int globalVar;
//..etc

#ifdef __cplusplus
}
#endif

Now in your C++ file you can just write

// my_cpp_code.cpp

#include "my_cpp_friendly_c_header.h"

So if you know that your C code will be included into C++ source, it’s always a good idea to wrap it in extern “C” { … } to avoid headaches later on…

More info over at: http://www.parashift.com/c++-faq-lite/mixing-c-and-cpp.html

It’s been 14 very long days, but Apple finally approved Flyloop. Go check it out, here’s the iTunes Link: Download

And of course, check out http://www.flyloop.com