Posts Tagged ‘JAVASCRIPT’
Cocos2D has been ported to run in javascript and called cocos2d-javascript by Ryan Williams.
Cocos2D is a game engine similar to Flash in that it is a 2d engine but it natively renders to OpenGL ES. Cocos2D-iphone was originally a port of Cocos2D, a python game engine. But the similarities to Flash and DisplayObjects = Nodes, Sprites, Scenes, Layers etc. This helps to port games over fairly quickly or start in productive in cocos2D.
Having this in javascript is a great thing! It runs on html5/canvas/javascript.
Cocos2d-javascript is a 2D game/graphics engine based on cocos2d-iphone but designed to run in the web browser. It uses the latest features available in HTML 5 allowing real-time rendering of 2D graphics without the need for plug-ins such as Adobe Flash.
While HTML 5 is still new and not fully supported across all browsers it won’t be long before the vast majority of web users are able to enjoy all that it offers. When this time comes cocos2d-javascript will be an excellent way to develop games and applications.
To see a small sample of what is on offer, please check out the demo section.
cocos2d engines are now available on almost all platforms, so if you are building a 2d game and need a 2d engine typically with Box2D physics, cocos2d offers lots of ways to get the game out there with some porting work.
- cocos2d-javascript (web)
- cocos2d-iphone (mobile)
- cocos2d-iphone site (objective-c)
- cocos2d-android-1 (java)
- cocos2d-android (java)
- cocos2d – original python (desktop)
- cocos2d other
- cocos2d-x c++ (C++ port for win, iphone, android-ndk)
- Similar to cocos2d – andengine (android java)
EaselJS is a new library from Grant Skinner that somewhat mimics the Flash display list/display object heirarchy. It is the result of the game Pirates Love Daisies which demonstrates some great gameplay in html5.
The API is loosely based on Flash’s display list, and should be easy to pick up for both JS and AS3 developers. In our preliminary testing, Easel appears to be fully compatible with iOS, Android, and all major browsers that support the canvas element.
Lots of great javascript libraries have been made public including such contributions as this, Three.js (3d canvas/svg/webgl), Lettering.js (typography), audio.js (audio) and many many others, a complete pipeline is emerging. EaselJS adds to that a helpful flash like api for html5 (<canvas> + javascript).
The API contains these familiar classes for Flash/AS3 developers:
DisplayObject
Abstract base class for all display elements in Easel. Exposes all of the display properties (ex. x, y, rotation, scaleX, scaleY, alpha, shadow, etc) that are common to all display objects.
Stage
The root level display container for display elements. Each time tick() is called on Stage, it will update and render the display list to its associated canvas.
Container
A nestable display container, which lets you aggregate display objects and manipulate them as a group.
Bitmap
Draws an image, video or canvas to the canvas according to its display properties.
BitmapSequence
Displays animated or dynamic sprite sheets (images with multiple frames on a grid), and provides APIs for managing playback and sequencing.
Shape
Renders vector drawing instructions within the context of the display list.
- EaselJS
- Grant Skinner Post on EaselJS
- EaselJS Examples: game, sparkles, rollover / drag & drop, localToGlobal, globalToLocal, sprite sheets
Helpful tool for taking vector art from Adobe Illustrator .ai assets and exporting them as html5 with canvas script.
It is a visitmix lab product so it is a Microsoft tool. Mike Swanson has builtmany great conversion tools for interactive such as SWF2XAML (silverlight/wpf markup).
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..
Here’s a look at another interesting flash player implementation by Joa Ebert using Java with OpenGL rendering support. It is at an early stage but has the right idea in hardware rendering to OpenGL which is easily cross platform and mobile capable with speed.
This project is pretty new but there is work to make it web browser capable either in a java applet or a plugin for IE/FF/WebKit/etc but there are also others that are out there using alternative renderers. Most of these are in early development with varying support and do not currently compare to Adobe’s Flash Player versions. However the hardware rendering ones like JITB may beat it fairly quickly once all the other features are added. Complete OpenGL based renderers like Unity or WebGL are fast and can run pretty heavy rendering because of hardware acceleration for all drawing and native support.
Other Flash Player implementations:
- Lightspark
- AS3 script via LLVM
- Written in C++ (very portable for native)
- OpenGL accelerated rendering
- Smokescreen
- runs in Javascript/Canvas/html5
- limited support
- Swfdec
- Firefox plugin
- Early development
- Gnash
- flash 7-9 support
Flash Players that use OpenGL as the renderer are nice because cross platform support is easier. The reason why OpenGL is a great idea is it is so cross platform on desktop and on mobile, it is also coming soon in WebGL for the browser hopefully.
Versions of OpenGL and support
- OpenGL ES
- OpenGL ES 1.1 = OpenGL 1.5 and lower (fixed function)
- Android
- iOS devices 3rd gen and lessx
- OpenGL ES 2.0 = OpenGL 2+ (current version 4.1 – shader capable).
- iPhone (3GS or later), iPod Touch (3rd generation and later) and iPad
- Android 2.2+
- WebGL
- OpenGL ES 1.1 = OpenGL 1.5 and lower (fixed function)
- OpenGL
- Windows
- OSX
- Linux
There is still a clear open field for an open source player to match something like Moonlight for Silverlight or hardware rendered canvas. WebGL would be great to have in time if it gets support but it is also nice to have a compiled language in the content that works in the player faster than scripting but with the ease of scripting. Plugins are still very relevant if they can address that.
Unity is a great and agile company that responded to the iOS4 changes with something very nice, a C++ option to develop with the Unity engine on the iOS. They will implement this if using Mono is barred which so far hasn’t happened. I have to say I wish this was an option for the Unity Engine all the time and hope they implement it anyways. For now Joachim Ante on the the Unity blog says this:
We continue to be excited about the iPhone, iPod touch and iPod as platform targets for Unity developers. While we don’t think C++ is the best language to write game code , using C++ as a scripting language has memory and performance advantages on low-end devices. This is a great feature to have for developers who want to squeeze the last ounce of memory & performance out of their games.
We still can’t believe Apple will force developers into choosing a specific language for development. And as mentioned, Apple is still approving every Unity-based game we know of. In case the situation changes, rest assured that we are working this Plan B.
We’ll be ready to talk more about this as well as share some time-line information with you soon, while of course waiting to find out if any of this will actually be necessary.
The Unity Plan B is that the C++ engine code that mimics as closely as it can to the Mono .net C# or Javascript code. From the samples on the blog the C++ and Mono (javascript in this case) samples are really similar.
Many current engines are legacy or have lots of bloat, unless you write your own, or maybe even still then. Though this is looking really clean for C++ game engine code, at least in comparison to current industry leaders for indie engines.
It would be a beautiful C++ library to use even if Apple doesn’t require it. Compared to the other indie game engines out this would be a sweet C++ engine for indies and hope they do this no matter. C++ can be written cleanly and with influence from a simplified C#/Javascript engine and clean API it makes for a killer C++ engine that makes sense. Right now native is really attrctive on embedded for some years to come.
A very basic comparison from their blog:
Javascript Sample
function Update(){ //Spin the object around the world origin transform.RotateAround(Vector3.zero, Vector3.up, 20 * Time.deltaTime); }
C# Sample
using System.Collections; using UnityEngine; public class Example : MonoBehaviour { void Update(){ //Spin the object around the world origin transform.RotateAround(Vector3.zero, Vector3.up, 20 * Time.deltaTime); } }
C++ Sample
#include "UnityEngine.h" class Example : public MonoBehaviour { public: void Update() { transform.RotateAround(Vector::zero, Vector3::up, 20 * Time::GetDeltaTime()); } };
Things I am wondering…
- Will this help porting to Android versions if they use the NDK?
- How much smaller will my app be if I use the C++ version (attractive feature since the mono dlls are pretty big – even though I really dig mono)?
- Wouldn’t a C++ version be a better base with pluggable scripting in C# if you want? Maybe an option for Lua with a similar API signature for all? Ok maybe over-engineering there…
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; init(); 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; particle.updateMatrix(); scene.add( particle ); } document.body.appendChild(renderer.viewport); } function loop() { renderer.render(scene, camera); }
Gordon, a flash runtime written in javascript, is an interesting project that recreates the Flash Player into svg using javascript from a flash source swf file.
UPDATE: Also check out smokescreen for the same, html5/javascript interpreting SWF files.
This is an interesting direction. There are most likely many things that do not work about this approach for existing content. But it is also a neat way to create new content that might be simple enough to play on desktop and a mobile version.
All these examples work on an iPhone or iPod Touch.
- Gordon on github by Tobias Schneider
- Demos posted for viewing by Paul Irish
So many cool and useful technologies are unveiled at SIGGRAPH every year, this year at SIGGRAPH 2009 was no different. Khronos Group, behind the new guidance of OpenGL, OpenGL ES, OpenCL, OpenVG, COLLADA etc, came another big announcement about hardware rendering within the browser. WebGL is now an official standard being developed at Khronos Group to bring javascript control of OpenGL to browsers… Wow!
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.
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.
