Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Android NDK Game Development Cookbook

By : Sergey Kosarevsky, Viktor Latypov

4 (5)

Android NDK Game Development Cookbook

4 (5)

By: Sergey Kosarevsky, Viktor Latypov

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.

Preface

Preface

What this book covers

What you need for this book

Who is this book for

Building the source code

Conventions

Reader feedback

Customer support

Free Chapter

1. Establishing a Build Environment

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

2. Porting Common Libraries

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

3. Networking

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

4. Organizing a Virtual Filesystem

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

5. Cross-platform Audio Streaming

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

6. Unifying OpenGL ES 3 and OpenGL 3

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

7. Cross-platform UI and Input Systems

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

8. Writing a Match-3 Game

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

9. Writing a Picture Puzzle Game

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

Index

Customer Reviews

4 (5)

5 star

60%

4 star

20%

3 star

0%

2 star

0%

1 star

20%

Supporting multiple CPU architectures

Android NDK supports different CPU architectures such as ARMv5TE and ARMv7-based devices, x86, and MIPS (big-endian architecture). We can create fat binaries that can run on any of the supported platforms.

Getting ready

Find out the architecture of your Android-based device. You can do it using the adb command as follows:

>adb shell cat /proc/cpuinfo

How to do it...

The following are the two approaches to pick an appropriate set of CPU architectures:

By default, the NDK will generate the code for ARMv5TE-based CPUs. Use the parameter APP_ABI in Application.mk to select a different architecture, for example (use only one line from the following list):
```
APP_ABI := armeabi-v7a
APP_ABI := x86
APP_ABI := mips
```
We can specify multiple architectures to create a fat binary that will run on any of them through the following command:
```
APP_ABI := armeabi armeabi-v7a x86 mips
```

There's more...

The main pitfall of the fat binaries is the resulting .apk size, as separate native code versions are compiled for each of the specified architectures. If your application heavily uses third-party libraries, the package size can become an issue. Plan your deliverables wisely.

Visually different images

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Android NDK Game Development Cookbook

Search

Your notes and bookmarks