Android NDK Game Development Cookbook

Android NDK Game Development Cookbook

Overview of this book

Android NDK is used for multimedia applications which require direct access to a system's resources. Android NDK is also the key for portability, which in turn provides a reasonably comfortable development and debugging process using familiar tools such as GCC and Clang toolchains. If your wish to build Android games using this amazing framework, then this book is a must-have.This book provides you with a number of clear step-by-step recipes which will help you to start developing mobile games with Android NDK and boost your productivity debugging them on your computer. This book will also provide you with new ways of working as well as some useful tips and tricks that will demonstrably increase your development speed and efficiency.This book will take you through a number of easy-to-follow recipes that will help you to take advantage of the Android NDK as well as some popular C++ libraries. It presents Android application development in C++ and shows you how to create a complete gaming application. You will learn how to write portable multithreaded C++ code, use HTTP networking, play audio files, use OpenGL ES, to render high-quality text, and how to recognize user gestures on multi-touch devices. If you want to leverage your C++ skills in mobile development and add performance to your Android applications, then this is the book for you.

Android NDK Game Development Cookbook

Credits

About the Authors

About the Reviewers

www.PacktPub.com

Preface

Free Chapter

Establishing a Build Environment

Introduction

Installing Android development tools on Windows

Installing Android development tools on Linux

Creating an application template manually

Adding native C++ code to your application

Switching NDK toolchains

Supporting multiple CPU architectures

Basic rendering with OpenGL ES

Going cross platform

Unifying the cross-platform code

Linking and source code organization

Signing release Android applications

Porting Common Libraries

Introduction

Compiling the native static libraries for Windows

Compiling the native static libraries for Android

Compiling the libcurl networking library

Compiling the OpenAL library

Compiling libvorbis, libmodplug, and libtheora

Using the FreeImage graphics library

Using the FreeType library for text rendering

Implementing timing in physics

Rendering graphics in 2D

Setting up Box2D simulations

Building the ODE physical library

Networking

Introduction

Fetching list of photos from Flickr and Picasa

Downloading images from Flickr and Picasa

Performing cross-platform multithreading

Synchronizing native cross-platform threads

Managing memory using reference counting

Implementing asynchronous task queues

Handling asynchronous callbacks invocation

Working with the network asynchronously

Detecting a network address

Writing the HTTP server

Organizing a Virtual Filesystem

Introduction

Abstracting file streams

Implementing portable memory-mapped files

Implementing file writers

Working with in-memory files

Implementing mount points

Enumerating files in the .zip archives

Decompressing files from the .zip archives

Loading resources asynchronously

Storing application data

Cross-platform Audio Streaming

Introduction

Initializing OpenAL and playing the .wav files

Abstracting basic audio components

Streaming sounds

Decoding Ogg Vorbis files

Decoding tracker music using ModPlug

Unifying OpenGL ES 3 and OpenGL 3

Introduction

Unifying the OpenGL 3 core profile and OpenGL ES 2

Initializing the OpenGL 3 core profile on Windows

Initializing OpenGL ES 2 on Android

Unifying the GLSL 3 and GLSL ES 2 shaders

Manipulating geometry

Unifying vertex arrays

Creating a wrapper for textures

Creating a canvas for immediate rendering

Cross-platform UI and Input Systems

Introduction

Processing multi-touch events on Android

Setting up multi-touch emulation on Windows

Handling multi-touch events on Windows

Recognizing gestures

Implementing an on-screen joypad

Using FreeType for text rendering

Localization of in-game strings

Writing a Match-3 Game

Introduction

Handling asynchronous multi-touch input

Improving the audio playback mechanism

Shutting down the application

Implementing the main loop

Creating a multiplatform gaming engine

Writing the match-3 game

Managing shapes

Managing the game field logic

Implementing user interaction within a game loop

Writing a Picture Puzzle Game

Introduction

Implementing picture puzzle game logic

Implementing the animated 3D image selector

Page-based user interface

Image gallery with Picasa downloader

Implementing the complete picture-puzzle game

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Synchronizing native cross-platform threads

Synchronization is required to prevent different threads from accessing shared resources simultaneously. A piece of code that accesses a shared resource—that must not be concurrently accessed by more than one thread—is called a critical section (http://en.wikipedia.org/wiki/Critical_section). To avoid race conditions, a mechanism is required at the entry and exit of the critical section. In Windows applications, critical sections are part of the WinAPI and in Android, we use mutexes from the pthread library, which serve the same purpose.

Getting ready

Android native synchronization primitives are POSIX-based. They include thread's management functions, mutexes, conditional variables, and barriers. Take a look at the header file platforms\android-14\arch-arm\usr\include\pthread.h in your NDK folder.

How to do it...

Let's create an API-independent abstraction to synchronize threads:

class Mutex
{
public:
  Mutex()
  {
#if defined( _WIN32 )
    InitializeCriticalSection...

Android NDK Game Development Cookbook

Android NDK Game Development Cookbook

Overview of this book

Related Content you might be interested in

Current Title:

Android NDK Game Development Cookbook

Synchronizing native cross-platform threads

Getting ready

How to do it...