Posts Tagged ‘ENGINE’

Tuesday, December 3rd, 2013

There are tons of javascript engines out there that are partial or full game engines for javascript and html.  Choosing one is quite difficult so Breakouts is there to help you compare with a common game ‘Breakout’ across all your favorites and some you might not know.

Feature Comparison

Current Breakouts

Thursday, September 1st, 2011

It’s aliveUnity Technologies has a preview of their Unity export to Flash 3D (Molehill now called Stage3D) posted.  Unity and Flash exporting was announced earlier this year. This is great as it provides huge benefits for Unity developers and Flash developers for games.

Over the last few months here at Unity, we have been hard at work on, amongst many other cool things, the ability to publish from Unity to the Flash Player. This means that next to the already existing build targets of a Unity project, one will be able to target Flash with Stage3D, announced for Flash Player 11.

A sneak preview

This video preview shows the Shadowgun game demo by Madfinger Games, a highly anticipated iOS & Android Unity built game. Except now, it is exported for and running in the Flash Player !

Unity provides the 3d + editor pipeline tools that are arguably the best for web/mobile/desktop/console games.  Flash it ubiquitous across all browsers and Unity content will be seen more often if users already have Flash and don’t need to download the Unity WebPlayer plugin. I do hope the Unity WebPlayer stays strong but if Flash 3D Stage3D low level player can integrate 3d with user interfaces kind of like how games use scaleform for killer interfaces layers on and into high quality hardware accelerated games, then we are all in for a treat, both developers, designers and consumers.

Unity is smart to provide more and more platform exports that are solid but I’d also like to see exporting to html5/WebGL. But for controlling the experience entirely in a plugin today, Unity and Flash are the top two interactive and gaming plugins that provide tremendous content and opportunity for the web. Unity also provides for better low level export to Android and iOS (in addition to desktop mac and pc, consoles). Seems like Adobe should buy Unity soon but hope that they don’t sometimes as the competition is nice.

How are the new Stage3D APIs different from the 3D functionality introduced in Flash Player 10?

In Flash Player 10, we introduced APIs that allowed ActionScript developers and designers to apply 3D effects to 2D content. Those 3D effects allow developers to add perspective and projection to content – which could also be described as 2.5D or “postcards in space.” Additionally, these 3D effects are software rendered and cannot be used for highly complex scenes with a lot of content to render.

The new low-level APIs will provide advanced 3D and 3D engine developers the flexibility to leverage GPU hardware acceleration for significant performance gains. Today, Flash Player, renders thousands of non z-buffered triangles at approximately 30 Hz. With the new Stage3D APIs, developers can expect hundreds of thousands of z-buffered triangles to be rendered at HD resolution in full screen at around 60 Hz. Using the new 3D APIs in Flash Player and AIR will make it possible to deliver sophisticated 3D experiences across almost every computer and device connected to the Internet.

Why is Adobe adding 3D functionality to Flash Player?

3D has been one of the most popular requests from our customers. Enabling true 3D experiences in Flash Player aligns with Adobe’s commitment to innovation and delivering a more complete Flash Platform.

Adobe evolved the web with video and now we are going to evolve the web again with 3D. From interactive websites, e-commerce, and marketing to gaming, 3D will be available to everyone, everywhere.

Does this mean the 3D APIs introduced in Flash Player 10 will be deprecated?

No, the initial 3D APIs introduced in Flash Player 10 continue to provide designers, interactive designers and developers a simple way to apply 3D effects to 2D content. The new low-level 3D APIs are targeted to advanced developers for building complex 3D experiences leveraging GPU hardware acceleration. Choosing one API over another one will depend on the use case and type of content created.

What are the requirements for 3D to work in Flash Player?

We are working to ensure 3D content always works with the best performance, regardless of context and hardware configuration. The 3D APIs will rely on DirectX 9 on Windows and OpenGL 1.3 on MacOS and Linux. For mobile platforms, Flash Player will rely on OpenGL ES 2.0. For those graphics cards that aren’t supported, Flash Player will elegantly fallback to a fast software rasterizer called SwiftShader, a technology licensed from TransGaming.

How do the Stage3D APIs compare to WebGL’s proposal to have the capability be available through browsers and HTML5?

In terms of design, our approach is very similar to the WebGL design. However, we offer a consistent, browser-agnostic solution that will enable advanced 3D experiences on almost every computer and device connected to the Internet. Additionally, GPU-accelerated 3D in Flash Player will build on all the expressiveness features that exist today in Adobe Flash Player.






Monday, October 11th, 2010

Pretty promising project over at PhobosLab of the Impact Game Engine running on the iOS platform using the JavaScriptCore Framework. The best part is it has all Canvas calls passed into run on OpenGL ES thus the speedy demo.

Biolab Disaster on the iPhone 3GS from Dominic Szablewski on Vimeo.

The game is running in its own process and is not using the iPhone’s browser at all. Instead, it’s just using the JavaScriptCore Framework to run the game. All the necessary calls to the Canvas API have been reimplemented with OpenGL-ES and the touch input is passed over to JavaScript to be evaluated by the engine. I of course had to make some changes to the engine, but the game source code is exactly the same as for the web version.

This would probably never fly on the App Store because it executes code or interprets it but is a very nice experiment. More discussion at Hacker News..

Saturday, July 24th, 2010

A sweet engine for getting started with Android game development is the andengine 2D OpenGL ES engine. This is very simple and compares with cocos2d-iphone for iOS development in 2D with OpenGL ES.  They both support a wide range of 2d techniques with an OpenGL renderer.  Some great videos are posted on the andengine google code page showing a box2D example, multiplayer example and more.

Mobile games are on slower hardware, similar to later 90′s computers so native is a great way to go for 3d and 2d game development because of this limitation at the current time and well into the next few years.  Take this time to learn you some native gamedev. andengine isn’t native directly as it is Java based but compiled with the Dalvik JIT virtual machine. Another way to go native on Android is the Android NDK which allows C and C++.

The engine also has extensions that can be easily added and some great ones exist already.

Sunday, April 25th, 2010

A new Javascript 3D Engine that can render to Canvas and SVG has been released by mr. doob.

Mr. doob is a well known Flash developer that has added many great experiments and cool contributions without being stuck to one technology, making some great interactive projects in javascript, chrome experiments and html5 (canvas/svg) in addition to the work in Flash with toolkits like Papervision 3D.  Recently the Harmony html5/javascript sketching project generated lots of interest for an html5 sketching app.

Three.js is great because it is a 3d engine built with renderers in SVG and Canvas makes to a really good base for modular, cross platform 3d engine right now (as soon as IE9 joins the party). For a while a good javascript rendering library will need to support multiple renderers for browser differences in performance and supported dependencies like canvas, svg and webgl. Three.js has that reality as part of the design.

Currently the engine only supports particles and triangles/quads with flat colors. The aim is to keep the code as simple and modular as possible.

At the moment the engine can render using <canvas> and <svg>. WebGL rendering would come at a later stage but feel free to fork the project and have a go.

Although this allows 3D for iPhoneOS and Android platforms the performance on these devices is not too good.

Sample Code:

var camera, scene, renderer;

    setInterval(loop, 1000 / 60);

    function init()
        camera = new Camera(0, 0, 1000);

        scene = new Scene();

        renderer = new CanvasRenderer();
        renderer.setSize(window.innerWidth, window.innerHeight);

        for (var i = 0; i < 1000; i++)
            var particle = new Particle( new ColorMaterial(Math.random() * 0x808008 + 0x808080, 1) );
            particle.size = Math.random() * 10 + 5;
            particle.position.x = Math.random() * 2000 - 1000;
            particle.position.y = Math.random() * 2000 - 1000;
            particle.position.z = Math.random() * 2000 - 1000;
            scene.add( particle );


    function loop()
        renderer.render(scene, camera);

Tuesday, March 9th, 2010

Unity is showing no signs of slowing down in making a consolidated, easy pipeline for game developers and creators to bring their wares to the masses on the top platforms. Already Unity 3D is the best 3d web browser plugin at the current time with export paths to web, desktop (mac and PC), iPhone/touch and Wii. But now we will see support for PS3, iPad (obvious as it is a iPhone/touch) and Android (most likely with the help of the C++ NDK rather than the Java SDK).  XBOX 360 support was announced last year.

This is pretty huge even for such a small and innovative company. I guess it means it will be time to buy an upgrade soon. Unity so far has been giving feature after feature for free for current license holders, this one seems big enough to justify a major version increase.

Gamasutra comments on other great features:

This third iteration will also incorporate Umbra Software’s occlusion culling product, which is designed help performance for games with large, open scenes and complex geometry. The platform’s top-end version, Unity Pro, will include both Umbra and Beast at no additional cost.

Unity Technologies updated its Unity iPhone for version 3.0 to include streaming audio support for smaller build size, Bluetooth multiplayer support, faster in-game GUIs”, and a 2D sprite engine. Furthermore, the company’s iPhone product will offer performance improvements that promise to provide faster frame rates.

The company says that with its new platform support for PlayStation 3, iPad, and Android, it offers developers an opportunity to target a larger install base than any other game engine. Unity’s game engine currently can produce games for Windows, Mac, iPhone, and Wii, with support for Xbox 360 announced last October.

Friday, February 12th, 2010

Balder was one of the first 3d prototype engines in Silverlight and it has evolved quite nicely.  Balder by Einar Ingebrigtsen is described as a “Managed GameEngine with both 2D and 3D support targetting Silverlight, Xna and OpenGL.”

The sample browser will show you what Balder is capable of and it has come pretty far since the first version showing a wireframe teapot.

You know you’ve made it as a 3D engine when there are Augmented Reality apps for it.

Here’s a glance at what some of the C# source looks like for a feel of the engine code from the Silverlight4 TestApp:

using Balder.Core.Execution;
using Balder.Core.Objects.Geometries;
using System;
using Balder.Core.Lighting;
using Balder.Core;
using Colors=System.Windows.Media.Colors;
namespace Balder.Silverlight4.TestApp
    public class MyGame : Game
        public override void OnInitialize()
            Camera.Position.X = 0;
            Camera.Position.Y = 0;
            Camera.Position.Z = -80;
            var light = new OmniLight();
            light.Diffuse = Color.FromSystemColor(Colors.Green);
            light.Ambient = Color.FromSystemColor(Colors.Green);
            light.Specular = Color.FromSystemColor(Colors.White);
            light.Position.X = 0;
            light.Position.Y = 0;
            light.Position.Z = -130;
        public override void OnLoadContent()
            var teapot = ContentManager.Load("teapot.ase");
        private double _sin;
        public override void OnUpdate()
            Camera.Position.X = (float)(Math.Sin(_sin)*80);
            Camera.Position.Y = 0;
            Camera.Position.Z = (float)(Math.Cos(_sin) * 80);
            _sin += 0.05;
Thursday, July 16th, 2009

Haxe Sandy is a version of Sandy that can export to an experimental Javascript 3D engine taking advantage of the <canvas> element. There are some great demos that run smoothly in canvas capable browsers and very smooth in Chrome.

Demos of Haxe Sandy:

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.

[ via Matthew Casperson at ]

Sunday, June 21st, 2009

This is a very cool project called V8-GL.  It is an OpenGL engine with 80% of the API converted to run on the V8 Javascript engine, the same engine that runs Google Chrome.

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.

Thursday, April 30th, 2009

Yogurt3D flash based 3d engine appeared recently and is another flash based 3d engine which is based on OpenGL called SwiftGL and is stated as open source.

The site mentions that OpenGL source can be converted to run in the engine.  You can do this now with Alchemy although it is in very early stages.  It is not clear if it is an automatic conversion or if it simply means it is similar in syntax and method signatures, objects etc.

I definitely will be watching and see how it progresses, there isn’t much other than a single post about the engine so far and no info on the api or sample code.  Looking forward to seeing more, the z-sorting is quite nice.  Doesn’t appear like collisions are there yet but it has a nice look.

Sometimes excellent toolkits come out of the blue like this such as Ffilmation (isometric flash engine) or Alternativa (flash 3d engine flash 10 focused) so you never know.