This blog post will walk you through the Add-on from start-to-finish.

Get your BlackBerry Signing Keys

Before you begin you need to register for BlackBerry Signing Keys, which lets you develop your Unity games and publish to BlackBerry World. After signing up, you should receive 2 .csj files that will be used to generate the Signing Keys. If you already have your Signing Keys setup, move on to the next section.

Setup your Signing Keys

Once you have the Unity Beta SDK installed, make sure you register your computer for BlackBerry development. This can be done through Unity’s Build Settings at File->Build Settings. You will find the BlackBerry option among other platforms.

Note: if BlackBerry is not among other platforms, it is probably because you do not have a Pro license or it is not unlocked for the BlackBerry 10 Add-on. You can find more information on activating your Trial Pro license in the Unity Beta forums.

1. Register

   Clicking on the “Player Settings” will open up the BlackBerry Platform settings tab.

   Note: If you already have setup the BlackBerry Signing Keys with other BlackBerry Developer tools, the BlackBerry Add-on should detect and show you as Registered.

   

If you have not already registered your computer, click the Register Button and that will pop-up a screen where you can specify the appropriate .csj files that you received in your email. The CSJ Pin corresponds to the pin that you entered when filling out the Signing Key form. The CSK Password that you enter will be your actual Signing Key password that you should make sure to remember.



2. Backup and Restore

   Once you have registered, make sure to backup the generated Signing Keys. It is very important that you backup the Signing Keys as this will allow you to develop, publish, and upgrade your game from different computers. Once backed up, you can simply use the Restore button to register a different computer for development.

   Keeping your Signing Keys safe and remembering your password saves you a lot of potential hassle!

3. Unregister

   The Unregister button removes any Signing Key information from your computer. It is highly recommended to backup your keys in order to be able to publish or upgrade your games in the future. Unregistering your Signing Keys without a backup will make it impossible to retrieve them.

Debug Tokens

To securely develop, debug, and test your Unity Games, you’ll need DebugTokens.

If you already have a BlackBerry 10 Development environment setup, you can simply import your existing debug token from the following default folders:

• Windows XP: %HOMEPATH%\Local Settings\Application Data\Research In Motion
• Windows Vista and Windows 7: %HOMEPATH%\AppData\Local\Research In Motion
• Mac OS: ~/Library/Research In Motion
• UNIX or Linux: ~/.rim

To create a new debug token, click Create and the following window will pop-up to let you specify where to create a DebugToken and for which device based on the device PIN. The PIN of a BlackBerry 10 device can be accessed from the Settings screen in your device.

Before uploading the Debug Token, make sure that:

1. The device is in the development mode.
   It can be done at Settings Screen-> Security and Privacy -> Development Mode
2. Device IP Address and device password are entered

If you have a USB cable then enter the Development IP Address starting 169.254.x.x in the Device Address text box. If you prefer deploying wirelessly, make sure your device is connected to the same Wi-Fi network and enter the Network IP address that can be found under Settings Screen -> About -> Network ->IP. In both cases, development mode has to be turned on.

To verify that the Debug Token was successfully uploaded, check the development mode screen for the Debug Token details.

For security reasons, the generated Debug Tokens are only valid for a month. For example, if you have a debug version of a Unity game installed on your BlackBerry with an expired token, the game will not launch unless it is renewed. You can renew any existing or expired Debug Tokens within the settings. You may also edit a Debug Token to add or remove BlackBerry Device PINs for development.

Build and Deploy

Assuming you were able to import your game and upload the debug token, here’s how to enable optimizations and deploy to a BlackBerry 10 Device.

1. Texture Compression

   Depending on the Device’s GPU, you can compress your textures to a GPU-specific texture compression format to improve performance, loading time, and of course, reduce the texture memory size. The following options are available in the Build settings:



• PVRTC – To optimize your existing textures to Power VR GPU.
  Note: among the current Z10 and Q10 Devices lineup, Model Name STL100-1 indicates a PowerVR SGX544 GPU.
• ATC – To optimize your existing textures to Adreno GPU, which is present in majority of BlackBerry Z10 and Q10 devices.
• ETC1 or RGBA16 – To optimize your textures to the standard texture compression format included with OpenGL ES 2.0 extensions. Note: ETC1 is used to compress only opaque textures.
2. Build Type

   If your project is in development phase, use the Local Build Type with the development option turned on. This enables the Unity Script Debugging and Profiling feature. If you wish to test your game in release mode or submit it to BlackBerry World, choose the Signed Build Type.

   Note: To deploy a Signed Build, you do not need a Debug Token to be uploaded to a device. This allows you to distribute you game for Beta testing without having to distribute a Debug Token.

   

   Before submitting your game to BlackBerry World, explore the options under the BlackBerry platform settings to choose your game’s Resolution and Presentation options, Icon, Splash Screen, rendering optimizations etc.

   Now that you are up and running, lets see those amazing titles on BlackBerry World!

   And of course, for any questions, comments, concerns, or kudos feel free to reach out to me directly at rmadhavan@blackberry.com or connect directly on Twitter at @rmadhavan7.

With the upcoming release of BlackBerry Q10, there’s never been a better time to bring over your BlackBerry Z10 game and start monetizing on the new form factor. In this post, I will be talking about various porting considerations and best practices to help you get started and ensure that your game runs the best on Q10.

Let’s start off with the hardware differences:

The BlackBerry Q10 uses the same chipset and GPU as BlackBerry Z10 variant B with Qualcomm Snapdragon MSM8960 and Adreno 225. The main differences that you need to consider are aspect ratio, screen size, orientation and physical keyboard.

Aspect Ratio

If you have designed your game around the 16:9 or 15:9 aspect ratio, you will need to evaluate how to layout your game content to adapt to the 1:1 aspect ratio. There are various approaches you can take to accomplish this. You might be tempted to take the easy approach of simply scaling your game screen to 1:1 aspect ratio by using letter boxing. This approach is not recommend as it could negatively impact user experience of your game.  Since The BlackBerry Q10 has a smaller screen compared to the BlackBerry Z10, you will significantly reduce the game interaction area and waste precious screen space that could otherwise be utilized for game content such as HUD or controls. For a landscape game, one approach you could take to solve this is to use a comprise aspect ratio such as 16:11.  For the BlackBerry Z10, display more content on the sides and for the BlackBerry Q10 display more content at the top and bottom.

Similarly for a portrait game (9:15 or 9:16), you can display more content at top and bottom on the BlackBerry Z10 and more content at the sides on the BlackBerry Q10. In the below example, Bejeweled 2 displays the time progress bar at the bottom on the BlackBerry Z10 and on the side on the BlackBerry Q10.

If you are using any aspect ratio specific static assets such as backgrounds, images and splash screen, they will need to be scaled accordingly. For the standard splash screen, the BlackBerry Native SDK allows you to manage multiple device specific splash screens in the same bar-descriptor. For the BlackBerry Q10 you can add a 720×720 splash screen by editing the bar-descriptor using the IDE or a text editor. Here’s an example:

<splashScreens>
        <image>splash_1280_768.png</image>
        <image>splash_720_720.png</image>
</splashScreens>
      <asset path="assets">assets</asset>
      <asset path="icon.png">icon.png</asset>
      <asset path="/Users/pratiksapra/assets/splash_1280_768.png">splash_1280_768.png</asset>
      <asset path="/Users/pratiksapra/assets/splash_720_720.png">splash_720_720.png</asset>

Once you do this, correct splash screen will be automatically chosen depending on the device your game is launched on.

Next, if your game uses overlay controls such as virtual joysticks, UI elements and menus, you will need to reposition them as needed. The best approach is to lay them out relative to screen width and height thus making them aspect ratio independent. Below is an example of a flexible UI layout used in Bard’s Tale that works on both aspect ratios.

Screen Size

The BlackBerry Q10 features a 3.1” screen surrounded by a gesture sensitive bezel. If your game uses on-screen controls, it’s important to place them away from the bottom edge of the screen to prevent accidental swipes. An accidental swipe-up gesture during game play will thumbnail your game and cause unnecessary interruption for the user.

Optimizing your game controls is also really important. For example, If your game uses dual virtual joystick control scheme, I would recommend reducing this to just one on-screen joystick.  Due to smaller screen size, the user might end up covering most of the screen when controlling both joysticks using two fingers. We will talk about a solution to this in the later part of this post.

Orientation

The BlackBerry Z10 supports portrait as the default orientation. If you are setting the orientation in the bar-descriptor for your game, you might be wondering whether this would work on the BlackBerry Q10 without the overhead of creating a separate binary with a different bar-descriptor. To make your life easy, we have made sure that both portrait and landscape orientation settings map to portrait orientation on the BlackBerry Q10. The below example shows how your game would be oriented on the BlackBerry Z10 and the BlackBerry Q10 based on the bar-descriptor orientation setting.

Input

The BlackBerry Q10 features a physical keyboard so your game needs to be aware of this. If your game contains any buttons to activate the virtual keyboard, you should make sure they are removed or disabled when the game is running on the BlackBerry Q10. Unlike the virtual keyboard, the physical keyboard is always there and can be utilized as an input mechanism.    You can combine keyboard input with touch screen to offer an intuitive and robust input scheme for your game. For example if you want to optimize the dual virtual joystick input mechanism for the BlackBerry Q10, you can substitute one of the joysticks with keyboard input. Or if your game only requires gamepad style input you can use the keyboard as a gamepad.

Integrating keyboard input in your game is super easy. To accomplish this, in your main event loop simply handle the SCREEN_EVENT_KEYBOARD event and check for the keydown value. Here’s a code snippet on how to do this:

if (screen_get_domain() == domain) {

        screen_event_t screen_event = screen_event_get_event(event);

        int screen_val;
        screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &screen_val);

        switch (screen_val) {
        case SCREEN_EVENT_MTOUCH_TOUCH:
//handle touch events

        case SCREEN_EVENT_KEYBOARD:
            screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_KEY_FLAGS, &screen_val);

            if (screen_val & KEY_DOWN) {
                screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_KEY_SYM,&screen_val);

                fprintf(stderr, "The '%c' key was pressed\n", (char)screen_val);

                switch (screen_val) {
                case KEYCODE_W:
                    // Handle Up
                    break;
                case KEYCODE_A:
                    // Handle Left
                    break;
                case KEYCODE_Z:
                    // Handle Down
                    break;
                case KEYCODE_D:
                    // Handle Right 
                    break;
                case KEYCODE_L:
                    //Button A
                    break;
                case KEYCODE_P:
                    //Button B
                    break;
                case KEYCODE_K: 
                    //Button X
                    break;
                case KEYCODE_O:
                    // Button Y
                    break;
                default:
                    break;
                }
            }
            break;
        }

Tools & Deployment

To get started, you will need the latest BlackBerry Native SDK 10.1, which includes BlackBerry Q10 support. If you are running an older version please upgrade by visiting http://developer.blackberry.com/native.

To deploy your game on BlackBerry World, follow the regular process for creating a new release in the Vendor Portal. In the supported devices screen, make sure you select BlackBerry Q10.

Known Issues

There are two known issues with earlier versions of 10.1 device software that you need to be aware of.

• Audio – In-game audio playback results in complete loss of device audio and a reboot is required to restore audio.
• Orientation – If the orientation is set to landscape in the bar-descriptor, the app splash screen and system dialogs such as volume are incorrectly oriented.

Both of these issues have been fixed in the latest 10.1 device software posted at the below link so if you are running an older build please upgrade.

https://developer.blackberry.com/blackberry10devalpha/devalpha_update.html

I hope you found the information included in this post useful.  If you have any questions or feedback please leave a comment below or reach out to me directly on Twitter @pratiksapra.

The BlackBerry Gaming team is back from an awesome Game Developer Conference 2013 held last week in San Francisco. The crew was there with the BlackBerry Gaming Booth to show off gaming on BlackBerry to gamers and game developers from around the world.

During BlackBerry Jam Europe 2013, we made a big announcement about Unity support for BlackBerry 10. The big news this time around was the announcement of the Open Beta SDK release that will start in the next few weeks. We have been hard at work to provide a Unity Add On integrated with cool BlackBerry 10 features that game developers have been asking for.

Gamers and game developers got to experience some of the features of the Unity Add On for BlackBerry 10 at Unity’s BlackBerry Pod space. That turned out to be the busiest station we have ever manned. The gamers were stunned at seeing a BlackBerry Z10 turn into a high performance mini console with a simple HDMI cable and a Bluetooth HID Steel Series gamepad controller. They were further excited by the fact that BlackBerry 10 now supports some very popular gamepads out there right out-of-the-box and this feature integrated directly with the Unity SDK. The goal is to have game developers make as little code changes as possible to port their games over along with seamless gamepad support.

Along with the BlackBerry Lead Developer from Unity and CEO of Darkwind media, Scott Flynn, I was co-presented three exciting  Unity Booth sessions and a very well received GDC session on Professional Game Engines for BlackBerry 10. For those who missed the sessions, the GDC Session will be directly made available through the GDC vault.

If you are looking to be the first ones to port your Mobile Unity Games to BlackBerry 10, pre-register here for the Unity BlackBerry 10 Open Beta. As a participant in our open beta for the Unity BlackBerry 10 add-on, you get the chance to see how your content will run on this new global platform, and give feedback for improvements directly to Unity developers.

And of course, for any questions, comments, concerns or kudos on the Professional Game Engines, Middlewares or Gaming frameworks for BlackBerry feel free to reach out to me directly at rmadhavan@blackberry.com or connect to me directly on Twitter at @rmadhavan7.

Happy BlackBerry Gaming!

We love working with developers from all around the world and especially if they make cool games that we can play on our new BlackBerry 10 devices! Right after BlackBerry Jam Asia 2012, we had an amazing opportunity to work with incredibly talented game developers from the Asia Pacific Region. To give you an idea on the amount of travelling it took: 16 days, 8 cities, 39800 miles per head!  The best part was we found 260 happy game developers at the end of the trip.  The GotGame Port-a-thon event comprised of locations spanning six Asia Pacific countries including Thailand, Singapore, Australia, Indonesia, India, Hong Kong and China.  During these intense one-day events, we got a chance to work with some amazing talent from the gaming industry.  As a result, almost 800 high quality game titles were submitted over a span of just three weeks!

We would like to give a BIG Thank you to all the game developers who participated in these events and made GotGame Port-a-thon LIVE a huge success!

For a closer look at what Marmalade is capable of make sure you check out this demo of Nick using Marmalade Quick to build a 2D application really fast with Lua and Cocos2d.

Have you used Marmalade to create apps for BlackBerry 10? We’d love to hear about how your experience has been so far!

I’ve heard a lot of people claim that the gamepad is dead – doomed to be replaced by touch screens. I disagree with this sentiment.  There’s nothing wrong with mobile games using cool new control schemes that make good use of touch screens – but if I’m playing a game that was designed with gamepads in mind, like Shadowgun, why can’t I just use a real controller?

Well, now I can – and so can you. Check out gamepad support now being added in upcoming Unity 4 for BlackBerry 10:

After years of being frustrated by touch screen gamepads, I’m excited about bringing physical gamepad support to the Native SDK for BlackBerry 10. By making use of the new Gamepad API features developers can make their games work with physical controllers, giving their players the tactile responsiveness they’re used to from consoles and desktop PCs. When this is combined with BlackBerry 10’s built-in HDMI connectivity, you end up with a console experience in your pocket!

Here is another video showcasing gamepad pairing instructions and a racer sample on GamePlay3D that now supports not only desktop gamepad support but also BlackBerry 10:

Before you get started implementing this in your own game, I want to answer a few of the most common questions people ask me about the API.

1. What gamepads are supported right now?
   1. The SteelSeries Free.
   2. The Gametel.
   3. The Wii Remote.  Note that currently only the core buttons on the remote itself are supported – that means no attachments and no motion controls, just the D-Pad and other buttons.
2. If new gamepads come out, do I have to update my game to support them?
   1. No, you don’t!  When new controllers become available, we’ll update the mappings in a system update and your game will start receiving gamepad inputs from the new hardware.  Because the Gamepad API is an abstraction above HID, and because we map each gamepad’s unique HID report format to the Gamepad API, you don’t need to write any code that’s specific to a single controller.
3. Do users need to install anything to set up or configure their gamepads?
   1. No.  The Gamepad API is integrated into the Screen library, the same library you are already using to handle touch, keyboard, and other input events.  All users have to do is pair their device through the Bluetooth settings screen for it to start sending inputs to your game.

We realize there are other gamepads out there and continue to work towards supporting as many devices as possible. If you know of a Bluetooth, HID-compatible game controller that’s not supported yet, please let us know in the comments. Meanwhile, the fact that you won’t have to change your code when we add more devices to the list means you only help yourself (and your users) by starting to use this new feature right away.

Here’s a tutorial that should get you up and running. It includes plenty of code snippets and is based on this open-source sample project, which started as a little app I whipped up to test the new API. It eventually turned into a demo of two-player connectivity and a configuration screen.  I hope you find it useful.

Please, for the sake of everyone who’s ever been frustrated by touch controls, try this new feature and leave your feedback – I’m eager to do what I can to help if you have any trouble.  Most of all, I’m looking forward to playing your games with a real gamepad!

Links:

• Tutorial
• Sample code
• SteelSeries Free
• Gametel

In my last blog post, you got Up and Running with Cocos2d-x library on BlackBerry 10. Assuming you are well ahead in porting your game, may I suggest a wonderful idea to make your game go viral? Make use of Scoreloop and the power of our Social Gaming hub.

BlackBerry 10 comes with a lot of surprises for gamers including the introduction of the BlackBerry Social Gaming Hub via the Games app. Gamers can now meet new friends, discover popular games and share their experience through the Games app.

It doesn’t stop there. The Games app enables Scoreloop-integrated games to automatically post activities such as achievements, challenge results and high scores to a gamer’s timeline. With over 250 Million users already playing Scoreloop-powered games across platforms, this gives any game a great chance make a viral impact. There are also some good featuring opportunities in the “Games” section of the games app.

In this post, I will walk you through the process of integrating Scoreloop into the cocos2d-x BBTemplate project we setup in my last blog post. The instructions are generic enough and can applied to any other open library with minor modifications.

Set up Scoreloop account

First, create a Scoreloop developer account at https://developer.Scoreloop.com. If you already are a BlackBerry user and have a BlackBerry ID, there is no need to create a new account. Simply choose “Login with BlackBerry ID” and enter your BlackBerry ID credentials.

After logging in, you will see three options. You can skip the first option as the BlackBerry 10 Native SDK comes preloaded with the Scoreloop SDK and there is no need to download any external libraries. Now create a game title and choose “BlackBerry” option. If the game’s name is not already taken, a profile will be created.

Once the game account is created, you will see various options to customize your game’s social gaming options. If you already have an account and have already published titles using Scoreloop, you can choose the newly created game from the drop down menu.

Getting started

Follow the instructions below to include the Scoreloop library to the BBTemplateProject.

1. Right click the game project settings
2. Select C/C++ Build -> Settings -> Tool Settings -> QCC Linker
3. Add “scoreloopcore” library to the list of Libraries

To be able to make use of Scoreloop’s features, the infrastructure need to be setup and it all starts with creating an instance of Scoreloop client. Add Scoreloop’s main header file in HelloWorldScene.h and add the below mentioned Scoreloop variables in the “HelloWorld” class.

#include <Scoreloop/Scoreloopcore.h>

In your Scoreloop account, fetch the application data corresponding to your game title from the “Game Overview” section. It should look something like this:

Platforms	BlackBerry
Game ID	xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxx
Game Secret	Xxxxxxxxxx
Game Currency Code	IBI

Add this information to your code along with the game version and language:

static const char SCORELOOP_GAME_ID[] = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx";
static const char SCORELOOP_GAME_SECRET[] = "xxxxxxxxxx";
static const char SCORELOOP_GAME_VERSION[] = "1.0";
static const char SCORELOOP_GAME_CURRENCY[] = "IBI";
static const char SCORELOOP_GAME_LANGUAGE[] = "en";

In the init() method, initialize the Scoreloop client and its data components as shown below:

SC_InitData_Init(&scData);
SC_Error_t errCode = SC_Client_New(&client, &scData, SCORELOOP_GAME_ID, SCORELOOP_GAME_SECRET, 
SCORELOOP_GAME_VERSION, SCORELOOP_GAME_CURRENCY, SCORELOOP_GAME_LANGUAGE);

Note: If the user had not already setup his Social Gaming Hub account, he may be prompted to sign in with his BlackBerry ID and credentials.

Fetching information from the Scoreloop server

To fetch user information from the Scoreloop server, a Scoreloop user controller needs to be created. Queries receive asynchronous response and needs a callback function to be registered. In the snippet below, fetchUserComplete will be called upon a response from the server.

SC_Client_CreateUserController(client, &userController, fetchUserComplete, this);

For example: if the game needs to query the current session user’s information call

SC_UserController_LoadUser(userController);

Once a user controller is successfully created, it can be used to query information. There are two approaches to get the desired information from the server.

1. Via BlackBerry Platform Services (BPS) events.
2. Using a custom events

Approach 1: Via BlackBerry Platform Services (BPS) events

Cocos2d-x absorbs all the BPS events in its implementation and you can modify the cocos2d-x source code directly and have it call back whenever a BPS event arrives. CCEGLView::handleEvents() is where the event handling takes place and it calls the callback function that was registered through the “setEventCallback()”. The advantage of this approach is that it does not have event-polling overhead. The code snippets below show the changes made to the cocos2d-x library and the BBTemplate project to accomplish Scoreloop event handling via BPS events.

CCEGLView.h

void * m_eventCookie;
CEGLViewEventCallback m_eventCallback;
void setEventCallback(CCEGLViewEventCallback callback, void *cookie);

CCEGLView.cpp

void CCEGLView::setEventCallback(CCEGLViewEventCallback callback, void *cookie) {
	m_eventCookie = cookie;
	m_eventCallback = callback;
}
bool CCEGLView::handleEvents() {
	...

	for (;;) {

		if (m_eventCallback != NULL)
		m_eventCallback(m_eventCookie, event);
...
    }
}

HelloWorldScene.h

void fetchUserComplete(SC_Error_t result);
static void fetchUserComplete(void* userData, SC_Error_t result) {
 (reinterpret_cast(userData))->fetchUserComplete(result);
}

HelloWorldScene.cpp

bool HelloWorld::init() {
...
scData.runLoopType = SC_RUN_LOOP_TYPE_BPS;
SC_Error_t errCode = SC_Client_New(&client, &scData, SCORELOOP_GAME_ID, SCORELOOP_GAME_SECRET, SCORELOOP_GAME_VERSION, SCORELOOP_GAME_CURRENCY, SCORELOOP_GAME_LANGUAGE);

CCEGLView::sharedOpenGLView()->setEventCallback(StaticOnScoreloopUIEvent, (&_scInitData);
...
}

static void OnScoreloopUIEvent(void *cookie, void *event) {
SC_HandleBPSEvent((SC_InitData_t  *)cookie, (bps_event_t *)event);
}
void HelloWorld::fetchUserComplete(SC_Error_t result) {
...
}

Approach 2: Via custom events

An alternative approach to handle Scoreloop events is to use the Scoreloop custom event queue. The difference here is that incoming Scoreloop responses are processed by periodic polling. The good news is that cocos2d-x already has an infrastructure to support scheduling and the disadvantage of this approach is that polling takes place periodically and sometimes even when no Scoreloop event is expected.

The custom event handler can be called in game’s update() function or scheduled via cocos2d-x schedule() function.

HelloWorldScene.h

void OnScoreloopCustomEvent(float o);
void fetchUserComplete(SC_Error_t result);
static void fetchUserComplete(void* userData, SC_Error_t result) {
 (reinterpret_cast(userData))->fetchUserComplete(result);
}

HelloWorldScene.cpp

bool HelloWorld::init() {
...
scData.runLoopType = SC_RUN_LOOP_TYPE_CUSTOM;
SC_Error_t errCode = SC_Client_New(&client, &scData, SCORELOOP_GAME_ID, SCORELOOP_GAME_SECRET, SCORELOOP_GAME_VERSION, SCORELOOP_GAME_CURRENCY, SCORELOOP_GAME_LANGUAGE);

// schedule to call this method with every frame
this->schedule(schedule_selector(HelloWorld::OnScoreloopCustomEvent));
...
}

void HelloWorld::OnScoreloopCustomEvent(float o) {
SC_HandleCustomEvent(&scData, SC_FALSE);
}

void HelloWorld::fetchUserComplete(SC_Error_t result) {
...
}

Well, there you have it – you are up and running with cocos2d-x and Scoreloop. Here are some great resources available to you to get more out of Scoreloop SDK:

Scoreloop SDK Guide

Scoreloop Integration Sample -101 Scoreloop Integration sample

Belligerent Blocks – A Sample 1 level game that showcases great use cases of Scoreloop

So, you want to add video to your native OpenGL application on BlackBerry 10? Below I’ll go through the steps that you need to complete in order to get it up and running quickly.

The first thing you’ll want to do is create a window group in your screen creation code. The window group will be used to attach the video window to. The code is as follows:

       // Window group name
static const char *window_group_name = "videowindowgroup";

       if (screen_create_window_group(screen_win, window_group_name)) 
       {
              fprintf(stderr,"screen_create_window_group failed");
       }

The next thing you’ll want to do is handle the initialization of the video screen. There is a screen event called SCREEN_EVENT_CREATE that you need to listen to and initialize the video screen as you see fit. For example, if I wanted my screen to take up an arbitrary width and height I could do the following:

       case SCREEN_EVENT_CREATE:
{
              screen_window_t video_window;
              screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_WINDOW, (void **)&video_window);

              int size[2];
              size[0] = video_width;
              size[1] = video_height;

              screen_set_window_property_iv(video_window, SCREEN_PROPERTY_SIZE, size);
              screen_set_window_property_iv(video_window, SCREEN_PROPERTY_BUFFER_SIZE, size);

              int order = 1;
              screen_set_window_property_iv(video_window, SCREEN_PROPERTY_ZORDER, &order);
              break;
}

It’s important to set the zorder on the video window as it’s behind your main window by default, so make sure the order is set to a positive number.

Once initialization is complete, you can create a method to play your video. You can just use mmrenderer in order to do the heavy lifting. We just need to point it to use the window group that we’ve already defined called “videowindowgroup”. An example might look like this:

// I/O devices
static const char *video_device_url    = "screen:?winid=videowindowgroup&wingrp=videowindowgroup";
static const char *audio_device_url    = "audio:default";

// Name of video context
static const char *video_context_name = "videocontextname";

// I/O variables
int                video_device_output_id = -1;
int                audio_device_output_id = -1;

// Renderer variables
static mmr_connection_t*     mmr_connection = 0;
static mmr_context_t*        mmr_context = 0;

int playVideo()
{
       int rc;

       /*
       * Configure mm-renderer.
       */
       mmr_connection = mmr_connect(NULL);
       if (mmr_connection == NULL) {
              return EXIT_FAILURE;
       }

       mmr_context = mmr_context_create(mmr_connection, video_context_name, 0, S_IRWXU|S_IRWXG|S_IRWXO);
       if (mmr_context == NULL) {
              return EXIT_FAILURE;
       }

       /*
       * Configure video and audio output.
       */
       video_device_output_id = mmr_output_attach(mmr_context, video_device_url, "video");
       if (video_device_output_id == -1) {
              return EXIT_FAILURE;
       }

       audio_device_output_id = mmr_output_attach(mmr_context, audio_device_url, "audio");
       if (audio_device_output_id == -1) {
              return EXIT_FAILURE;
       }

       /*
       * Build up the path to where the video is.
       */
       char cwd[PATH_MAX];
       char media_file[PATH_MAX];
       getcwd(cwd, PATH_MAX);

       rc = snprintf(media_file, PATH_MAX, "file://%s/app/native/myVideo.m4v", cwd);
       if ((rc == -1) || (rc >= PATH_MAX)) {
              return EXIT_FAILURE;
       }

       /*
       * Start the playback.
       */
       if (mmr_input_attach(mmr_context, media_file, "track") != 0) {
              fprintf(stderr, "failed to attach video\n");
              return EXIT_FAILURE;
       }

       if (mmr_play(mmr_context) != 0) {
              return EXIT_FAILURE;
       }

       return EXIT_SUCCESS;
}

Finally when we’re done, we’ll want to clean up the window and the mmrenderer contexts:

void clearVideoScreen(screen_event_t screen_event)
{
       mmr_stop(mmr_context);
       mmr_output_detach(mmr_context, audio_device_output_id);
       mmr_output_detach(mmr_context, video_device_output_id);
       mmr_context_destroy(mmr_context);

       mmr_context = 0;
       video_device_output_id = -1;
       audio_device_output_id = -1;

       mmr_disconnect(mmr_connection);
       mmr_connection = 0;

       int order = -1;
       screen_set_window_property_iv(video_window, SCREEN_PROPERTY_ZORDER, &order);

       int visible = 0;
       screen_set_window_property_iv(video_window, SCREEN_PROPERTY_VISIBLE, &visible);

       screen_destroy_window(video_window);
}

Hopefully this gives you a good start into incorporating video into your BlackBerry 10 applications. For some other related samples of using video, you can check out the VideoPlayerSample in the Cascades-Community-Samples and also the Video Overlay sample in the native samples.

There are many ways to develop games or applications for BlackBerry 10. This is a good thing, but if you have not developed for the BlackBerry platform or you are familiar only with the older Java-based platform, it may be overwhelming. What are your options, and how do you get started?

Several factors can help you decide which path to follow. BlackBerry 10 has four primary developer platforms, each with its own distinct style of development, advantages and frameworks you can choose from.

In this first blog post, we’ll provide an overview of some of the options available on our native development platform.

Native

The bedrock of a good developer platform is a high-performance, low-level native implementation – and BlackBerry 10 delivers. The native platform is POSIX-based, so everything from “int main(void) { printf(‘Hello World’); }” and up will run on the operating system.

Whether you are a C++ guru or you shy away from low-level code, BlackBerry 10 supports a wide variety of choices on the native development platform.

Straight C/C++

http://developer.blackberry.com/native/beta/

BlackBerry 10 is based on QNX, a powerful, stable operating system that has been refined for over 30 years. Thanks to the POSIX interface, standard Unix C/C++ will run on the platform, without additional bootstrapping. You have full access to system APIs, from the networking stack to EGL and OpenGL and the flexibility to use common practices like dynamically loading libraries.

I personally ported a significant game framework to BlackBerry in only two days, and I have heard many more stories of developers with similar experiences on the native platform. If you like C/C++ development, BlackBerry 10 is a very exciting platform.

Cascades

https://developer.blackberry.com/cascades/

If you are looking to create an application, Cascades is the Qt-based framework that we provide for the most natural of BlackBerry 10 experiences. Application code and rendering are handled in different threads, so even when you are doing heavy processing, the UI will run at a smooth 60 frames-per-second.

Many applications can be developed using C++ or using QML, or a combination of both. QML supports JavaScript, so even if you are a web developer, it can be easy to create native BlackBerry 10 applications using your existing skill-set. The BlackBerry Native SDK provides our Momentics IDE with designer support for Cascades, so you can preview and fine-tune the layout of your applications without deploying to a device or a device simulator.

Marmalade

http://www.madewithmarmalade.com

We have partnered with Marmalade to provide a first-class experience for C++ developers using the Marmalade SDK. Similar to open-source solutions such as SDL and SFML, Marmalade is designed to provide a low-level compatibility layer between multiple platforms.

Marmalade also provides additional features – such as an optimized pipeline for art assets – tailored for every target device, as well as enterprise-level support.

NME

http://www.haxenme.org

We have also partnered with NME to provide support for BlackBerry 10. Unlike the other options you have as a native developer, NME does not require that you use C or C++. Instead, NME uses a language called Haxe that is compiled to C++ automatically, giving you the performance of C++ and OpenGL while creating an environment that should feel comfortable to a Flash or Java developer.

NME is an open-source, cross-platform framework that makes it simple to use graphics, sound, input, networking and the other features you need for 2D games and applications, including libraries such as Flixel or Box2D. NME can also uniquely target mobile, desktop, Flash Player and HTML5.

cocos2d-x

http://www.cocos2d-x.org

The C++ version of the cocos2d, the popular 2D gaming framework, is available for BlackBerry 10.
Similar to other versions of the library, cocos2d-x provides structured support for scene management, physics, particle effects, tiles, spritesheets and other game-specific features. Most of the framework can also be scripted using Lua or JavaScript. cocos2d-x is an open-source, cross-platform framework with support for both mobile and desktop platforms.

gameplay

http://www.gameplay3d.org

If you would like to develop 3D games using C++, gameplay is an excellent open-source framework which is fully supported on BlackBerry 10.

gameplay supports the standards you expect, such as OpenGL shaders, device input and particles, but also provides integrated support for physics, skeletal character animation, 3D audio and support for themeable 2D and 3D UI forms. If you would like to use a scripting language, Lua bindings are support. gameplay is cross-platform, supporting mobile and desktop platforms.

These are just a few of the choices you have on the native platform for BlackBerry 10, so don’t let this limit you. If you have any questions or would like recommendations, please feel free to sound off in the comments!

[YouTube link for mobile viewing]

You might remember the interesting story of Greek developer Charilaos Kalogirou, who ported his iOS game Pop Corny to the BlackBerry® PlayBook™ tablet and to the BlackBerry® 10 Dev Alpha device in just a few days. He blogged about how fast and easy the process was.

Now, after a few weeks, he’s back. Charilaos is participating to a competition organized by the Ludum Dare website, and I was happy to read that he decided to create a game exclusively for the BlackBerry PlayBook tablet. The competition is the following: finish a game, take it to market, earn $1. All in October.

Why did he decide to develop for the BlackBerry PlayBook tablet only? Well, he explains the reasons in this blog post. In particular:

“…we are going to exclusively target the BlackBerry PlayBook and the BlackBerry App World store, as it is a platform I fell in love recently and it’s a platform where you can actually make a buck these days.”

I think that says it all. More proof that if you want to make money with your apps and games, BlackBerry App World is the store for you.

Here it is, game ready: http://www.ludumdare.com/compo/2012/10/29/flycraft-we-made-it/ You can get it from BlackBerry App World here.