Avatar Core Issues are open

If you haven't already noticed (and some have), Issues are now open for the Avatar Core Project. The issues list will show you what's currently being worked on, or what thoughts are going into future development, as well as gives you an opportunity to log bugs or feature requests (that are within reason).

Avatar Core 0.5.5 Released

Avatar Core 0.5.5 Released is now available from the Avatar Core project page. As mentioned in the previous post, this update includes some bug fixes and some minor changes to the API. More information on what was changed can be seen in the release notes.

Also included in this update is a small JSFL command for users of Adobe Flash Professional. This command can read the contents of the current timeline and the selection in the Library in Flash and generate XML based on their contents. When I get a chance, I'll try to write up some more information on how it works including providing a sample FLA.

I do feel this release is starting to shape up, and I feel more comfortable with how things are coming together. There are still a few more additions I would like to make before hitting 1.0, though. These additions should not affect any work being done with Avatar Core now, so I think it should be pretty safe to work with it now without having to worry about breakages.

Despite the past few months being slow, I hope to spend some more time working on the framework this spring.

New Avatar Core minor release coming soon

I've made some changes and improvements to the Avatar Core framework. There are some bug fixes, some API changes, and most notably, the ability to easily create copies of most objects via clone methods. Before, you could do this by writing and reading XML, but this way is a little easier. I'll have to update all the documentation, demos and samples to make sure they'll still work with the changes, then I'll post the update to the project page.

Avatar Core 0.5.0 + My Avatar Editor Lite

Avatar Core 0.5.0 has now been released on the project page (both SVN and ZIP download). The release notes have more information about the changes made.

It should be noted that the SVN repository has been redesigned to also include documentation, examples, and a library SWC for the framework. The location of the source files have moved a couple of directories deeper as a result, so you may need to make some changes with respect to classpaths/source path references. The ZIP download also reflects this restructuring, though it only includes the source code and the same selection example as before.

"My Avatar Editor Lite" is now a new demo example. The source is currently only available through SVN, though you can browse the demo source files through the project page. A live version of My Avatar Editor Lite is also viewable online. It's a great example in that it uses a lot of the features of the framework.


I've also combined the two new demos from before (with Fred) into one demo now listed in the SVN examples. It modifies position, scaling, and rotation using mouse interaction. However it doesn't go so far as to incorporate Constrain behaviors. The original demos will probably remain on the wiki for now unless they end up becoming incompatible with new releases.

So what's next? For one, the documentation will need updating. I don't think it covers a lot of the new changes very well and is pretty lacking in other areas too. With that, also more attention given to the documentation on the wiki. Then, its just a matter of tying up and loose ends preparing for a 1.0 release for production use.

Avatar Core Rendering My Avatar Editor Characters

I recently got an example using Avatar Core to render My Avatar Editor character heads up and running. It uses the same visual assets but none of the original codebase (My Avatar Editor does not use the Avatar Core framework; it was created before work on Avatar Core started).


Clicking on the head will get you a new random variation.

This will ultimately become another demo, but I still want to add controls for modifying characteristics - almost to parity with My Avatar Editor, but lacking anything that would unnecessarily over-complicate.

In doing this exercise, as expected, a number of additional bugs and limitations were addressed. They will be fixed in the next release due out with the completion of this demo.

Avatar Core 0.2.1 (SVN Only)

The svn repository for Avatar Core has been updated with the 0.2.1 changes. There shouldn't be anything broken, per se, in the current 0.2.0 download, so you can continue to use it for testing purposes. That download will get updated for the next release.

• Release notes

The next release will probably be a 1.0 release candidate. I'm going to sprucen up the documentation a bit more and try to make a 'lite' version of My Avatar Editor with the framework to see 1) if its possible, and 2) if it's easy, to moderately easy to use. Any problems found in that attempt will be fixed for that build.

If anyone has any bugs to report or feature requests, now's the time to do it. (And doing so through the blog is fine for now.)

Avatar Core Updates

A bunch of new Wiki pages have been added for Avatar Core, adding a little more in terms of explanation for the different parts of the framework. When I get around to it (though probably not any time soon), I'll try to include some additional visual aides and maybe demos, or links to demos that cover each specific topic.

Speaking of demos, the source code for the previously mentioned demos have also been posted there (Demos wiki page). However, there have been some problems with the hosting for myavatareditor.com where the files are hosted, so they might not be accessible at the moment.

When writing up some of the additional wiki documentation, I ended up adding a few more things to the framework. In other words, version 0.2.1 is looming. But I also just ran across another issue which is a little more serious and something that could require some additional changes to the API (never fun). I'll have to think about how to solve that problem and weigh in convenience vs. performance and all that jazz. Without getting into too much detail, the problem essentially boils down to art being loaded far often than it needs to be.

Avatar Core 0.2.0

Avatar Core version 0.2.0 (beta) is now available on through svn on the project page. The API documentation has also been updated. The release notes for 0.2.0:

=== 0.2.0 (August 28, 2009) ===

There have been a number of new API changes, as well as a reworking
of how parenting is handled. The new approach allows Constrain behaviors
to work better with parenting. In addition some rendering changes have
been made that change the effects of parent transforms on their children.

- Added Viewport.resetContent()
- Added a padding parameter to Viewport.fitContent()
- Added ThumbnailArtSprite class
- Added SourceLoaderSprite class as a base class for ArtSprite and
ThumbnailArtSprite
- Renamed AvatarArt to AvatarDisplay to prevent confusion with with the
Art/ArtSprite classes
- ArtSprites no longer redraw themselves (i.e. their feature) when their
feature property is set. This was creating many more calls to draw() than
was necessary, though may require additional manual calls for updates
- Scaling a parent feature no longer scales its children; child position,
however, is still affected by scale
- Renamed Transform to Adjust to prevent confusion with flash.geom.Transform
- Instead of mirroring features with a negative scale, flipX and flipY
properties have been added to the Adjust (Transform) class
- Fixed a bug in Adjust.add and Adjust.subtract where x and y were flipped
- Renamed "update"-related API in Feature and Avatar to "redraw"
- Changed parent-related API in Feature (removed getParentFeature, added
parent, [internal]parentCount, [internal]updateParent)
- Features are no longer hidden if their parent cannot be found. They are
instead left visible and treated as though they have no parent
- Added Feature.getConcatenatedParentMatrix()
- Added Avatar.updateParentHierarchy(). This is called frequently through
other APIs but may be necessary to call to make sure the parent
hierarchy of an avatar is accurate
- Added getDefaultPropertiesInXML to IXMLWritable, helping to reduce the
inclusion of default values in generated XML
- Range class now has a steps property
- Separated Constrain.position (Rect) to Constrain.x (Range) and
Constrain.y (Range)
- Removed Rect class (was only used by Constrain before)
- Constrain uses its Ranges' steps, if provided, to apply stepping
to constrained values
- Constrain is now applied to feature adjusts (transforms) rather than
directly to art sprites to allow child adjusts to honor the
constrain
- Added Constrain.name, making it more convenient to access Constrain
behaviors in a feature
- Other minor bug fixes

Complete ReleaseNotes.txt.

The wiki pages, demos, and non-svn downloads still need to be updated. I'll try to get to those in the next couple of days.

New Demos Preview

I've been working with some simple sample applications of the framework preparing for the next, soon to be released build of Avatar Core (0.2.0). The purpose of these samples was to make sure the features that have been implemented into the framework can actually be used when applied in the real world (vs. looking good on paper). The samples will be available for download and presented as demos on the Avatar Core project page when the 0.2.0 build is released.

The two sample demos previewed below demonstrate manipulating feature properties (position, size, and rotation) and the use of Mirror and Constrain behaviors. They use a new character I whipped up for these samples that I like to call Fred.

• Demo 1: AdjustConstrainedFeatures (seen above)
  
• Demo 2: DragConstrainedFeatures
  

The source for each demo only amounts to about 150 lines of code - this including the XML descriptor for the avatar (which takes up about 60 lines by itself). Again, these will be available (in FLA form) when 0.2.0 is released, shortly.

Considering new Avatar Core logo

This morning I was thinking about making a new logo for Avatar Core. The current logo looks too cold and doesn't really say "avatar" when you look at it, despite my attempts to incorporate an "A", a gear (being a framework), and a character's head - one which ends up looking more like a cycloptic robot.


I was also thinking, given that the project is based off of My Avatar Editor (and hosted from that domain), that maybe the logo should be more reflective of that project. I quickly slapped together two new variations of that logo which could serve as a replacement for the current Avatar Core logo. Anyone have any preferences? Stick with the current, go with one of the new variations, or think about it more and come up with something else?





Granted, the logo has no functional bearing on this project, but it is a fun aside to coding.

Back in the Saddle

I've started to get back into development of AvatarCore (the offshoot project from My Avatar Editor to serve as a framework for new avatar viewing/editing clients). So far I'm mostly just re-familiarizing myself with the codebase. Luckily the getting started docs I wrote weren't too shabby, so that hasn't been a difficult process. At the same time, its also good coming into a project with a fresh eye so it's easier to see where the problem spots might exist. I'm happy to say that it hasn't been too bad so far, though I do wish that some of framework was simpler. It's been a tough process trying to mix simplicity and ease of use with functionality. I'm not unhappy with what exists now, so not much of that will change.

Having said that, I've already been making some changes that are beyond simple additions or name changes, particularly with parent handling, that could potentially have a substantial impact on programming clients using AvatarCore. I'll try to release an update with those changes fairly soon. In the mean time, I had hoped to create some more sample applications to weed some of these issues out. A 1.0 release isn't going to happen until I'm able to whip together some scenario applications covering most if not all of the framework's capabilities.

Avatar Core Development Stall

For the moment, not much work is being done with Avatar Core. There are two main reasons 1) Busy with my day job (really busy) and 2) I'm not entirely sure where I want to go with the API.

The API is particularly important as JavaScript comes into play. There's two sides of Avatar Core with JavaScript. One side is the ability to provide a JavaScript API for talking with Avatar Core in SWF form (as seen in My Avatar Editor). The other side is being able to port the entire Avatar Core framework to JavaScript allowing for it to be used without the Flash dependency. And really, in general, it is good to have a solid, simple API for working with frameworks like this. The question is, how good is it now, and can it be "down-ported" to a less-capable environment gracefully. At the moment, I'm not sure, which is why I'm going to think about API direction for a bit before movin forward much more with improvements and other fixes, particularly what it means in terms of having a JavaScript implementation.

Avatar Core 0.0.5 Beta

A new release of Avatar Core is now available. This release is 0.0.5 beta. I figured it's far enough along now to take it out of alpha and bring it into beta, though I'll have to admit that kind of identification is fairly arbitrary (just look at how long Google tools remain in beta...).



For anyone wanting to keep track of project updates, I'd suggest not following this blog but instead keeping an eye on the Avatar Core project feeds of which there are a number to keep an eye on. I'll probably only update this blog moving forward with major releases or otherwise notably important news.

Next on my things to do is work on documentation. The API has already been updated, but I want to include better descriptions and getting started information on the wiki. Currently, a lot of the content there is no longer accurate.

Avatar Core 0.0.3

Avatar Core 0.0.3 is now available from the Avatar Core Project Page. The same structure of the framework remains mostly the same, though a lot of the API has changed. A lot of this is a result from the increased focus on allowing Avatar's to be able to be self-contained, without needing a library to link to. Currently, this does introduce a problem with some features of the framework (which will have to be figured out in the next release), but I think overall it's for the best.

The live demo has also been updated (and can be downloaded, with the framework, from the downloads page).

More information about this release can be found in the release notes.

Avatar Core API Docs

API Documentation is now available for the Avatar Core framework.

Avatar Core 0.0.2 Download Update

For anyone not wanting to mess with SVN on google code, I've added a download of the demo in the downloads page that includes the demo with the full framework source code. This will give you the necessary files to compile the sample right out of the box, or at least get you the full framework source code in one download without SVN.

FYI, the demo was created with Flash CS4. However, all source code is in external .as files, so you could easily recreate the FLA files in CS3 if you have that using the AS files as document classes for their respective FLAs. You can see a live demo here.

Keep in mind its still early, and changes may yet be made to the framework resulting in changes in functionality and/or API.

Avatar Core 0.0.2

Avatar Core 0.0.2 source code has been uploaded to the project on google code. More information on the changes can be found in the release notes. I'll try to get some more info on the wiki and a sample application in the downloads section a little later.

Avatar Core Design Basics

I've updated the wiki for the Avatar Core framework with the basic design of the framework. Source code is available now, but I'm already making some changes to it that I'll probably upload within the next couple of days. I hope to spend a lot more time working with this next week when I have some more free time available.

Avatar Core

I'm naming the new avatar framework Avatar Core. It will be (isn't yet) hosted on Google Code under MIT, just like My Avatar Editor. In fact it will essentially be under the My Avatar Editor umbrella, using www.myavatareditor.com as its home page - of sorts.

I've got a new, very simple Avatar Core demo online using a couple of the Mii character assets from My Avatar Editor. Like My Avatar Editor, it consists of two SWF files, the editor (seen in demo link), and the viewer. The editor loads the viewer, reads its definition (which it, in turn, loads from this XML file), and provides appropriate selections. Both the editor and the viewer were written in less than 100 lines of code each (not counting the Avatar Core framework). Because of the flexibility of this framework, you could potentially grab these SWFs now, put them on your server, and use your own XML definition and graphics to completely change the avatar and all of its features including what it displays and what it could potentially display as well as the options provided in the editor interface.



There have been a few changes in the XML since the last post. The most important are a couple of new features including default transforms and parent definitions. A transform represents how an avatar feature looks (position, scale, rotation). A default transform lets you specify a start transform when a feature is added to an avatar for the first time. Not a big deal, but helpful in terms of having these settings defined in the XML. Before, transform properties were only defined directly within avatar features. Now they exist within a separate transform object.

Parent definitions are definitions that another definition is attached to. Consider an earring on an ear. Both are separate features, but if an ear moves up and down the side of an avatar's head, that earring should follow it. By specifying the ear as being a parent to the earring definition, when the ear moves, so will the earring.

There have been some other naming changes and enhancements to reduce XML verbosity as well. I'm not sure if this will be the final format, but I think it's looking pretty good right now.

Moving forward I'll probably focus on more avatar/editor examples using more features (such as constraints and colors). This will hopefully also flush out any bugs if they exist.

Custom Avatar Editor Solutions

While its great that My Avatar Editor is open source and available for anyone to download, use, and/or modify at will, the solution it provides is primarily targeted towards recreating the Mii channel editor on the Nintendo Wii. The approach to the application's design and how it works with data makes it a little difficult to repurpose the editor for other situations. Before releasing My Avatar Editor, I did my best to make it easier to change that, but in the end, it didn't make too much difference.

Realizing this, I thought it would be a good idea to create a more generalized framework for developers that could be easily manipulated to match various requirements - this especially with the recent interest the My Avatar Editor source. And last week I started doing exactly that.


So far so good.

What I have, which is very limited, can produce some simple results on the avatar definition side of things, but sadly (I think), I may have made the process more difficult than it needed to be. In a way this is good because it means more features and flexibility, but it's also not very good in the fact that if people really want to use this thing, they're going to have to be able to understand it. I can say, however, that because I was using My Avatar Editor as a model, I'm pretty sure that this new framework could be used to easily and completely recreate My Avatar Editor from scratch. And hopefully its flexible enough to be extended to do much more.

A run-down of the features and what makes it so complicated (and, really, it's not that bad, I mean I've only been working on it in my spare time for a couple of days ;) includes:

• Constraints for avatar features including position, scale, and rotation
• Control over feature arrangement, including having one feature consist of multiple visual assets that can exist both above and below other features at the same time
  
• Feature-specific color transformation groups
• Everything defined in a flexible XML format

The last bullet point I think is the most important one, and really the others revolve around that. The importance here is that anyone can completely define avatar features in XML - not just the avatar itself (though it is also defined in XML) - but the actual features that are possible for the avatar to use and what they look like. These collections of features are known as a library, and you could potentially swap out libraries with each other to completely change an avatar visually without modifying its internal definition. And because they're all managed by XML, they can be easily changed outside of the context of the actual editor/avatar viewer applications.

Ok, ok, ok. You want to see where it's at right now? I wasn't going to show anything, but since I talked so much about it, you're probably curious. Ready? Here's an avatar it can show on the screen now:



WOWEE! I know you're floored. Maybe more interesting is the XML used to define this. You can find that here. Of course keep in mind that all of this is subject to change.

The idea is to hopefully release this along side My Avatar Editor as open source under MIT. I have a lot more work to do, and my day job has me busy at the moment, but I'll continue to post updates to the project on this blog. Also, as you might have guessed, the target platform is Adobe Flash Player, though I will not be targeting Flash Player 10 specifically as I did with My Avatar Editor. I'll be making this one also Flash Player 9 compatible.