Posts Tagged ‘ios’

Monday, July 22nd, 2013


Unity 4.2 update has been released and includes Windows Phone, Windows Apps for free and also included Blackberry 10 basic exporting.

Many other great features like source control support (text-based assets), realtime shadows and NavMeshes are now mostly available in free versions. Text based assets is the biggest helper when working with teams that use Unity Basic for assets or shared repos for basic/pro versions.

New platforms

Unity 4.2 comes with three new platforms: Windows Phone 8, Windows Store apps and BlackBerry 10. That’s right, we’ve doubled the number of mobile platforms Unity supports! Now it’s up to you guys to create new games and port existing titles to these platforms so even more people can benefit from your creative talents.

In Unity 4.2, all users of the free version of Unity can publish to any mobile platform they wish, be it Windows Phone 8, Windows Store, iOS, Android or BlackBerry 10 without it costing a dime. In addition, Unity Pro users can use the Windows Store Pro deployment option (which includes the Windows Phone 8 and Windows Store apps platforms) absolutely free of charge.

Plus, Unity Pro users can benefit from advanced Unity features when deploying their iOS, Android or BlackBerry 10 projects by purchasing Unity iOS Pro, Android Pro or BlackBerry 10 Pro Add-On products from the Unity Store.

I like the moves to free for all mobile platforms for basic and the Windows Phone and Apps Pro upgrades for free for Unity Pro users (Blackberry 10 Pro upgrade still is $1500).  I was hoping over time the Asset Store and a lower subscription would emerge and the ecosystem would grow.  The Windows addition for free is great for Microsoft’s platforms growing like iOS and Android did as Unity is a big push on game content to those stores/markets.

Other great feature updates in Unity 4.2

  • Shuriken Particle Collisions

Shuriken Collision Event Callback Scripting Interface: Efficient callbacks on GameObjects and Particle Systems are issued when Shuriken particle collisions occur. Per particle callback data includes collision positions, incident velocities, surface normals and Collider references. Use this feature to can cause damage to GameObjects and apply forces to rigidbodies.

  • OpenGL ES 3.0 for Android

ES3 has nicer shadow filtering, ETC2 texture compression, GPU skinning via transform feedback, HDR rendering, multiple render targets, derivative instructions in shaders etc.

Requires an ES3-compatible GPU, for example Qualcomm Adreno 3xx or ARM Mali T6xx.

Note that the official Android version does not support ES3 yet. So to test it you should install ES3 drivers directly from the GPU makers (e.g. Qualcomm).Platform switching, player building and asset importing can now be cancelled! How cool is that?

  • Platform Switching

Platform switching, player building and asset importing can now be cancelled! How cool is that?

  • 64-bit Mac Universal Exports

Mac OS X: 64 bit standalone player support (x86_64 and Universal).

 

Thursday, May 17th, 2012

cocos2d-x is the natural evolution of the cocos2d-iphone engine to C++ and it is stable and producing multiplatform games.

cocos2d-iphone is a great Objective-C game engine (and the first really) that began as a python engine called cocos2d and was ported to Objective-C + iOS early on in the iPhone SDK days.  Arguably Unity and cocos2d are the two biggest indie engines on the App store.  Cocos2D is a very simple engine and coming from Flash development many of the concepts are similar (i.e. Sprite, Actions/easing, Layers/Scenes (although slightly different), etc).  But getting your Objective-C game to Android and other platforms is not a fun task. There are other options like andengine for android from cocos2d port but each port only gets you so far as you still have two codebases for one game on iOS and Android.

Unity obviously can open up platforms for you but cocos2D-x can also do that for 2D games across iOS, Android, Blackberry Playbook, Windows, Linux and more! This is possible because like oolong engine and other custom multiplatform engines for mobile the core is in C++ with presentation view wrappers/stubs in Objective-C++/C for iOS, Java/C++/NDK for Android, etc. The list of games shows that it is stable and a well treaded engine including games like Hero Academy from Robot Entertainment.

cocos2D-x even has a port of cocos to C#/XNA for Windows Phone development using all the classes you know and love from cocos2d. That is actually pretty sweet to have similar logic to reach Windows Phone (Unity and others bypass because there is no native access by developers sadly still, must, use, XNA — strange considering Unity pushes C# development quite heavily but I digress).

drawlogic originally mentioned cocos2d-x over a year ago in a post about cocos2d-javascript just in an ‘other ports’ category but it has really come along and is quite stable as the game lists are showing. Take it for a spin if you need a cross platform 2D game! If I need to work on cocos2D games I would definitely go with the C++/Objective-C++ engine since it is now stable and gets you many platforms, I also still like developing in C++ which is very common in games for performance and multiplatform performance especially.

Other mentions

Sunday, April 17th, 2011

Recently cocos2d (iphone) reached version 1.0 and they have started a new cocos3d project!

cocos2d is a great objective-c engine for iOS development (and Mac development).  It has it’s limitations but for small 2d based games with physics or platformers with sprites it rocks.  It has made it to 1.0 and many games are made with it on the Appstore.  Unity and Cocos2D make up a good portion of the games in terms of engines used on the Apple Appstore for small to midsize game studios and indies (2500+ games are made with cocos2d).

cocos3d

cocos2d is getting a 3d extension in cocos3d for using 3d mesh/models etc.  Currently it only imports POD models but this could be good for smaller isometric 3d games or 2d using 3d models.  It is early so this will take some time to mature but good news for improving engine performance needed to handle 3d.

This could easily become the most popular/used 3d engine made with objective-c as cocos2d has done with 2d… there aren’t many pure objective-c game engines. The one downfall is multi-platform even though Objective-C is fun.  Unless it is solely a iOS or Mac title then going with a  multi-platform engine or a custom C++ engine and using Android NDK and an Objective-C wrapper on iOS is best for port economics and performance.  That can also be used as desktop and other platforms this way. But for iOS development cocos2D is great.

cocos3d Features

Some of the key features of cocos3d are highlighted in the following list:

  • Seamless integration with cocos2d. Rendering of all 3D model objects occurs within a special cocos2d layer, which fits seamlessly into the cocos2d node hierarchy, allowing 2D nodes such as controls, labels, and health bars to be drawn under, over, or beside 3D model objects.
  • Pluggable loading framework for 3D models exported from familiar 3D editors such as Blender3ds Max orCheetah3D, or through industry standard 3D object files such as Collada or PowerVR POD, or even from your own customized object file formats.
  • Imported 3D models can include animation sequences.
  • 3D model objects can be arranged in sophisticated structural assemblies, allowing child objects to be moved and oriented relative to their parent structure.
  • 3D models, cameras, and lighting can be manipulated and animated using familiar cocos2d CCActions, allowing you to quickly and easily control the dynamics of your 3D world, in a familiar, and easy-to-use programming paradigm.
  • 3D objects can be covered with dynamic materials and textures to create rich, realistic imagery.
  • Mesh data can be shared between 3D objects, thereby saving precious device memory.
  • Mesh data can freely, and automatically, use OpenGL vertex buffer objects to improve performance and memory management.
  • Culling of 3D objects outside of the camera frustum is automatic, based on pluggable, customizable object bounding volumes.
  • Automatic ordering and grouping of 3D objects minimizes OpenGL state changes and improves rendering performance. Pluggable sorters allow easy customization of object sorting, ordering, and grouping for optimal application performance.
  • Automatic OpenGL state machine shadowing means that the OpenGL functions are invoked only when a state really has changed, thereby reducing OpenGL engine calls, and increasing OpenGL throughput.
  • Sophisticated math library eliminates the need to use OpenGL ES function calls for matrix mathematics.
  • Fully documented API written entirely in familiar Objective-C. No need to switch to C or C++ to work with 3D artifacts.
  • Extensive logging framework to trace program execution, including all OpenGL ES function calls.
  • Includes demo applications and Xcode templates to get you up and running quickly.

Learn cocos3d

You can learn more about writing 3D iOS applications using cocos3d, by referring to:

 

 

Monday, November 22nd, 2010

WebSockets and many other great features are now available across the iOS devices that are updated to iOS 4.2.

You can test your devices for WebSocket support and I just tested iPad and iPhone/iPods on iOS 4.2 and it is a go.

The update also adds some other excellent Safari browser features including:

  • As mentioned, WebSocket support
  • Accelerometer support
  • Improved SVG and Canvas rendering
  • Better Ajax

The new Safari on iOS 4.2 makes the iOS platform the current best html5 mobile solution for interactive apps and games in the browser. This should add some fun in terms of interactive web, games and better web experiences for iOS users.

We hope they add in WebGL support soon, there was mention of WebGLRenderingContext but not supported in browser yet.

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..

Thursday, September 9th, 2010

Apple’s official statement on this topic.

Well good news, after the massive frenzy of 3.3.1 in the App Store Terms of Service, Apple has been wise to loosen restrictions on the AppStore for native apps that use scripting such as Mono, Actionscript, Lua and others as long as it doesn’t download any code (for security reasons). The apps have to be AOT Ahead of Time compiled which Unity, MonoTouch and the AIR iPhone Packager for Flash apps all use or the script has to be downloaded with the binary that was approved or an update (Lua scripting for instance).

This is a huge change in stance for Apple and basically allows Adobe Flash based AIR apps to run on the device natively again. I think this is a very wise decision by Apple to let the market decide on what is a quality app while respecting Apple’s concerns about downloading and running code that might create security concerns (non compiled script outside the web sandbox).

The only bummer is that we won’t see a C++ Unity version which was plan b. But the benefits are really great for all types of developers as long as it is safe and with Apple’s latest update, quality.

Developers using Unity, MonoTouch, Adobe Flash AIR Packager, Lua scripters etc are now all safe as long as it is AOT compiled and scripts it uses are downloaded with the binary and not downloaded later (only content and data can be downloaded unless it is in an approved app update).

All your technologies are safe… for now.. dun dun dun…

However Apple also tightened quality control so they will be rejecting bad or duplicate apps, so at the same time this has made it harder to get apps approved if there is questionable quality or too many of one type of app.  It is good on the surface but also I believe the store should be an open market where the best app wins, crap will naturally filter out.  This is probably a stop-gap for all the apps that will be submitted with AIR or other less complex platforms because more novice users will be submitting them.  So this is good for skilled developers on any platform making quality and original content.  But it could cause some problems.

Engadget has some nice covereage if you dont’ have access to the iOS developer site:

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.

Friday, July 2nd, 2010

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…