For some time now, there’s been a lot of work going on to overhaul Chromium’s graphics system. New APIs and markup like WebGL and 3D CSS transforms are a major motivation for this work, but it also lets Chromium begin to take advantage of the GPU to speed up its entire drawing model, including many common 2D operations such as compositing and image scaling. As a lot of that work has been landing in tip-of-tree Chromium lately, we figured it was time for a primer.

The primer they are looking at is not just rendering the content made in WebGL, CSS3 3d transformations and more but the entire final pass of the output.  This leads to some very interesting years ahead in browsers.  With Chromium, IE9, Firefox and Safari all now with aspects of hardware rendering and acceleration via the GPU, anyone not doing GPU acceleration is seemingly behind the curve that seemed to start in 2007ish to a culmination of today’s latest browsers.

After these layers are rendered, there’s still a crucial last step to blend them all onto a single page as quickly as possible. Performing this last step on the CPU would have erased most of the performance gains achieved by accelerating individual layers, so Chromium now composites layers on the GPU when run with the –enable-accelerated-compositing flag.

Web content will get really interesting over the next couple years.  Even basic computers now have a GPU and bottom of 32MB video memory.  Why aren’t we using those GPUs as much as possible for web content and web games. The time of software rendering might be coming to an end now that processors seem to have topped out and the bottom level computer is capable of handling a decent amount of video memory. It will be easier to justify useful graphics acceleration with a better user experience when we can take advantage of all the computer/device has to offer.

• Chromium Blog post about this development
• Differences between Chrome and Chromium (the project behind Chrome)

Google looks to be making a gaming site to compete with Facebook only kicking the gaming up a notch? By the comment from Mark DeLoura, head of developer advocate for Google gaming, it appears they/he also favor going 3d or native client with WebGL or Unity wrapped in the native client.

Check the comment by Mark DeLoura on the gamasutra post regarding the rumored Google Me Facebook like gaming/social site:

I think Flash will continue to be a very viable platform. The Flash toolset is pretty frickin’ amazing, and there are a ton of happy Flash developers out there, and great games galore.

I would like to see higher-fidelity 3D content on the web though. It’s been a dream of many people going back to VRML days. WebGL and Native Client are two solutions to this that will be integrated into the Chrome browser. At Google I/O we talked about Unity running inside of Native Client, which combines the hardware acceleration and security of Native Client with the fantastic toolset and runtime from Unity. It’s peanut butter and chocolate (well, for me). This is a platform I’m really excited about for 3D web games.

Indeed peanut butter and chocolate is mighty tasty.

The pipeline is not yet as streamlined as  as Unity 3D as Torque has many legacy formats and components such as DTS models, DIF interiors and DSQ animation files that are specific to the Torque Engine.  But they have added support for COLLADA models and the community is strong for Torque 3D. Also, since Torque 3D is built on an older engine but updated for modern uses, the file formats and loading is streamlined for low poly and web based games that need small asset sizes but still have quality.

Like Unity 3D there are many paths to truly get your game published and available to many platforms from desktop on Windows and Mac to web players in all major browsers (and iPhone, Wii and XBox with more $$$). This is an amazing time in game development.

When I initially got into heavier game development in early 2003 after moving from Half-life to Unreal and then the affordable Torque, there were two major things missing, a web player export and a good editor with intellisense.  Torque 3D provides the web player export and Torsion is a great IDE for TorqueScript beyond using Visual Studio or XCode for C++ source editing.

Some really nice tools include the River Editor and Road and Path editor that complement the great terrain editor and scene and asset editors that make production fairly quick in the Torque tool chain.

Road and Path Editor

Road and Path Editor – Torque 3D from TorquePowered on Vimeo.

River Editor

River Editor – Torque 3D from TorquePowered on Vimeo.

The good news is there is now two quality toolsets in Unity 3D and Torque that for about $1500 you can get a good pipeline and engine that will enable you to create great immersive games for many platforms and the web.  If you got the skills the platforms are there to get your game out to the world whichever platform you choose.  Similarly to the Flash vs Silverlight vs Canvas progress, with competition in this area it will keep both platforms innovating and supporting developers needs first.

For more immersive games that require hardware rendering beyond Flash capabilities Unity 3D and Torque 3D are now here for your creations.

Ok so this was officially announced at the GDC in March but limited information, but now it has been slated for an official public standard in early 2010. Shortly after the announcement at the GDC we saw Google o3D appear doing exactly that, controlling OpenGL through Javascript in the browser but it was still largely software/harward hybrid rendered. Google, Mozilla, Opera are part of the companies supporting WebGL which is great for browser support, also NVIDIA, AMD and Ericsson are in on it.

Khronos Details WebGL Initiative to Bring Hardware-Accelerated 3D Graphics to the Internet

JavaScript Binding to OpenGL ES 2.0 for Rich 3D Web Graphics without Browser Plugins;
Wide industry Support from Major Browser Vendors including Google, Mozilla and Opera; Specification will be Available Royalty-free to all Developers

4th August, 2009 – New Orleans, SIGGRAPH 2009 – The Khronos™ Group, today announced more details on its new WebGL™ working group for enabling hardware-accelerated 3D graphics in Web pages without the need for browser plug-ins.  First announced at the Game Developers Conference in March of 2009, the WebGL working group includes many industry leaders such as AMD, Ericsson, Google, Mozilla, NVIDIA and Opera.  The WebGL working group is defining a JavaScript binding to OpenGL® ES 2.0 to enable rich 3D graphics within a browser on any platform supporting the OpenGL or OpenGL ES graphics standards.  The working group is developing the specification to provide content portability across diverse browsers and platforms, including the capability of portable, secure shader programs.  WebGL will be a royalty-free standard developed under the proven Khronos development process, with the target of a first public release in first half of 2010. Khronos warmly welcomes any interested company to become a member and participate in the development of the WebGL specification.

Google released O3D this year and there are great strides in 3d within the browser from game engine wrapper technologies such as instant action technology, gaim theory engine (now owned by id Software and runs Quake  Live, hardware rendered Unity 3D (and Torque 3D coming soon), and Flash software rendered  3d engines Papervision 3D, Away 3D, Sandy (Sandy also released a haXe version that exports a javascript version) and others.  But it looks like the movement is to bring OpenGL to the web as a standard under the name WebGL, this would be great!  There would still be lots of times where plugins are better now and in the near future but the path is a good one. Having a software/hardware rendering hybrid like Google O3D for broad video card support (some of the painful older intel cards), or using a plugin like Unity3D, Torque 3D or wrapper technology for bigger engines is a good idea for the time being. But the future is grand in this area.

I think that Google O3D and OpenGL ES success on iPhone games probably combined to get this in motion.  OpenGL and very basic video cards are now standard in most machines out there.  Unity3D actually published hardware statistics on casual gamers (web-based games) ever so kindly and shows that even though there are some older Intel cards out there, for the most part machines nowadays have a video card capable of supporting at least low-poly 3d and hardware supported 2d rendering in real-time for games, user interfaces and more.

This is exciting news, it appears the movement of the web gaming market is getting much more capable and is accelerating the innovation of hardware accelerating the web.

Demos of Haxe Sandy:

• Displaying a model
• Getting Started
• Model Loading
• Physics
• Shading
• Tweening
• Skybox
• Primitives

Sandy was actually the first open source 3d engine in flash, maybe this will be a trend building in haXe for export to flash and javascript?  It certainly looks like a great start and would make a very nice platform for 3d on the web allowing Sandy or other flash libraries to run in Flash and Javascript by writing in an abstraction platform like haXe. Other libraries like Motor2, Physaxe, haxe3D, PureMVC and more have haXe versions. Still very experimental but a possible need when Flash and canvas are both in the market in the future.  Right now it is still all Flash.

• Haxe Sandy
• Haxe Sandy Demos
• Haxe Sandy Tutorials by Matthew Casperson
• Haxe Sandy Download
  • Download sources
  • Download API documentation
  • Download all examples to get started

[ via Matthew Casperson at devmaster.net ]

This is exciting as more productive languages like Javascript get speed boosts from engines like V8 and are capable of manipulating more complex systems like OpenGL.  Google is also pursing this in the browser with O3D with javascript manipulation of hardware rendering.  Also, a Google funded project called Unladen Swallow is converting Python to the LLVM virtual machine, so that it can have increasing speeds to compete with gcc speeds.

Making things easier to produce and control with more simplified and minimal languages like Javascript, Python and Actionscript etc that control more complex systems, that typically you would need to invest more time in such as a platform on C++ is the goal. V8-GL has this goal in mind.

V8-GL from the author states:

V8-GL intends to provide a high-level JavaScript API for creating 2D/3D hardware accelerated desktop graphics.

In other words, you can hack some JavaScript code that opens a desktop window and renders some 3D hardware accelerated graphics. Bindings are made using the V8 JavaScript engine.

• V8-GL blog post
• V8-GL source on Github
• Also check out the SpiderMonkey jslibs project with other javascript wrappers for libraries like ode, sdl and more using the engine by Mozilla.

AS3 Blender exporter has been updated to allow multiple object export. Also in April is was updated to export quads and modifiers.

One concern you might have is statically binding the code within a main swf fileon compile and resulting file size compared to loading in the DAE dynamically.  But you can just load these in as you would external DAE COLLADA files as compiled swfs and since it is just code it is very compact.   This adds some duplication of code (such as tweening libraries or the 3d engine source as needed) but allows a more horizontal loading or lazy loading of meshes when needed.

This is just another option to get 3D models into the flash 3d engine of your choice in addition to COLLADA, some MD2 support and limited ASE support.

This is an awesome project that keeps getting better, thanks Rozengain.

amfast is a new remoting library  that looks to be as sweet as pyamf (where sweet == fast and useful).  I am checking out amfast now but the speed boost alone might be worth it.  For instance, working with real-time games, when you need static content you need to grab that quickly sometimes via a content service.  The faster that link the better. It also has Twisted integration which is great for networking and SQLAlchemy integration which is in my opinion the best ORM for python (pyamf has twisted, django, pylons, sqlalchemy as well)

amfast is well documented and has some great examples.  If you have the Python addiction, check it.

Description

• AmFast is a Flash remoting framework for Python.
• AmFast can use AMF to communicate between Python and Flash, Flex, and any other system that supports AMF.
• AMF is a binary object serialization protocol used by Actionscript based applications.

Server Features

• Support for NetConnection and RemoteObject RPC.
• Support for Producer/Consumer ‘push’ messaging with HTTP polling, HTTP long-polling, and real-time HTTP streaming channels.
• Support for authentication with NetConnection and RemoteObject.
• Flexible Target mapping system to map message destinations to invokable Target objects.
• Support for ChannelSets with multiple Channels to expose resources in different ways.
• Built in Channels for CherryPy, Twisted Web, and plain WSGI.
• Support for configurable Endpoints. Use AmFast’s built-in AMF encoder/decoder C-extension, or use an external AMF encoder/decoder, such as PyAmf for a pure-Python implementation.

AMF Encoder/Decoder Features

• AMF0/AMF3 encoder/decoder written in C as a Python extension for speed.
• More than 10x faster than the PyAmf encoder/decoder (even when using PyAmf’s optional C-extension).
• Map custom classes with ClassDef objects for complete control over serialization/de-serialization.
• Full support for IExternalizable objects.
• Data persistence with SqlAlchemy including remotely-loadable lazy-loaded attributes.
• Actionscript code generation from ClassDef objects.

Augmented Reality and the base of the original ARToolkit has taken the flash world by storm with the FLARToolkit and really the speed updates of the AVM2 in Flash9 and Flash10 to be able to pull off the OpenCV calculations needed on the bitmap data from each frame of a camera. It has been around quite some time but now web based engines such as Flash and now Processing can take advantage of this awesome technology.

The Simple ARToolKit Library for Processing (PC) is just a basic port of single marker AR support and it currently only runs on windows.

Den Ivanov did some cool experiments with this kit but adding the capability to do multiple markers.  In his videos the processing runtime seems to process the render pretty quickly.  It seems that most Flash AR is around like 5-10 frames per second for the detection.

*mute the sound*

ARToolkit for processing tests from den ivanov on Vimeo.

I updated to iPhone SDK 3 beta 4 and iPhone OS 3 beta 4 and the latest Unity iPhone and things were much better in perception of speed at least in early testing.  Not sure if it was more from one or the other but the games I am testing/building so far are quicker and the OS feels faster overall.

Get the latest Unity 3d iPhone dev kit (only for Mac OSX obviously since it uses XCode to compile per Apple licensing requirements)

This build fixes many issues and makes some great optimizations for speed as listed here:

New Features and Improvements

• Reduced memory footprint for uncompressed audio by 50%
• “Memory usage for textures reduced by 50%. Texture memory is now freed once it has been submitted to OpenGLES on the device. The “Enable Get/SetPixels” flag in the Texture Import Settings lets you disable this feature on a per texture basis in order to access the texture data from a script using GetPixel etc.
• Improved iPhone script call optimization
• Removed unused parts of Mono runtime
• Reduced memory overhead while reading data from disk and slightly improved load times.
• Support for several predefined splash-screens (portrait/landscape) for Indie version. Just rename one of the splash-screens in the output directory to Default.png
• Exported audio session activation/deactivation functions to AppController.mm
• Added Scripting Reference code examples for iPhone specific APIs

Bug Fixes

• Fixed audio to play correctly after phone call / text message / alarm interruption occurs
• Fixed compressed audio occasionally refusing to play
• Fixed AudioSource.PlayOneShot to work correctly with compressed audio
• Fixed audio to respect Mute switch and background iPod music
• Fixed Pause function and time property for compressed audio clips
• Fixed OpenAL memory leak
• Fixed PhysX memory leaks
• Fixed Audio and Animation assets leaking while loading new scene
• Fixed a crash related to playing compressed audio in a sequence
• Fixed memory leak while updating Mesh geometry data
• Fixed several small memory leaks in rendering module
• Fixed asynchronous .NET sockets
• Fixed .NET threads
• Fixed cross thread boundary calling to the delegates
• Fixed UnityEngine.TextEditor stripping
• Fixed GUI slider stripping
• Fixed GUI scroll view stripping
• Fixed IndexOutOfRange exception checking
• Fixed Boo.Lang.dll stripping
• Fixed occasional crashes of AOT cross compiler