The libraries tested are:

• Eigen
• GLM
• CML

These choices are largely influenced by reading their websites and posts at the Game Development StackExchange site:

• Best C Math Library for Game Engine?
• High Performance Math Library for Vector And Matrix Calculations
• Complete Math Library for use in OpenGL ES 2.0 Game?

Requirements

I have several requirements for a math library, and when rating them (in no particular order) the following things are important:

• License
• Portability
• Quality and quantity of the documentation
• Completeness (or how much can the library do without me having to write my own functions). For game development this includes:
• Matrix operations
• Vector operations
• Complex number support
• Quaternion operations
• Extensibility and community contributions (linked directly to the above).
• Ease of use (are the concepts simple to understand?)
• Performance (are there SIMD optimisations?)

Libraries Overview

// You need to add path_to_eigen/unsupported to your include path.
#include <Eigen/OpenGLSupport>
// ...
Vector3f x, y;
Matrix3f rot;
glVertex(y + x * rot);

Quaternion q;
glRotate(q);

glm::vec4 v(0);
glm::mat4 m(0);
glVertex3fv(glm::value_ptr(v));
glLoadMatrixfv(glm::value_ptr(m));

To run the tests on Android you will need the Android NDK and android-cmake. For Ant you will need to specify your Android SDK location in android/local.properties. I have included prebuilt libraries for armeabi and armeabi-v7a so if you don’t want to compile them yourself you can skip straight to the ant commants.

Results

So far I’ve tested matrix addition and multiplication. src/Main.cpp contains code that will generate two lists of 1 million 4×4 float matrices for each library, populate them with random float values, and then add each one from the first column to the second. It will then do the same for multiplication. It will repeat this step 10 times and print out how long it took for each library.

Results for each library vary greatly with architecture and optimisation level. I have tested standard GCC build on Mac OS X Lion as well as an SSE enabled build, and armeabi, armeabi-v7a and armeabi-v7a with NEON instructions for Android.

Note that all tests use the -O2 GCC optimisation flag except the non-SSE laptop build which uses -O0.

Results for addition and multiplication are shown below. Note that the laptop I’m using is an i7 2.2ghz early 2011 MacBook Pro and the Android device is a Stock HTC Desire (2.2) with a 1 GHz Qualcomm QSD8250. All times are in milliseconds.

                        laptop  laptop (SSE)  armeabi  armeabi-v7a  armeabi-v7a with neon
Eigen additions         8065    30            9944     2181         2145
Eigen multiplications   22404   86            59460    5143         5113
GLM additions           2375    76            10256    1506         1407
GLM multiplications     7337    400           59008    2189         3108
CML additions           12336   96            9587     2885         2996
CML multiplications     21603   551           58399    5306         5280

The first column for the laptop doesn’t have any compile-time optimisations and is included purely for interest. From the other results, Eigen seems to be the fastest for these operations, but GLM is the fastest on the HTC Desire with both ABIs. I am not sure why the NEON times are not much faster (and in some cases, slower) but will update this post when I learn more.

Despite GLM being faster on the mobile devices, I am more inclined to use Eigen due to its speed on the tested Intel CPU and its much better documentation and more active community.

Also note: this isn’t an error, at the time of writing numbers 2 and 10 point to the same URL. Number 10 also seems to have a broken quote with half missing! Despite this, some of these articles are really interesting!

1. 25 Secrets of the Browser Developer Tools

   Superb explanation and introduction to how you use and get the most out of the Developer Tools in web browsers.

2. HTML Parsing with JavaScript

   Ever thought of implementing the DOM in JavaScript? David Flanagan shows with dom.js how it can be done.

3. How to Bulletproof @font-face Web Fonts

   Working with fonts on the web has always been a challenge. This article aims to clarify as much as possible and take you beyond the common pitfalls.

4. Interactive Periodic Table

   Beautiful example of using modern web technologies to create a periodic table – complete with moving atoms.

5. Fullscreen HTML5 video

   Watching video is nice but it is even nicer if you can do it in fullscreen. This explains how to tap into that possibility in web browsers.

6. Lights

   Interactive WebGL music experience.

   You can also see it in action here.

7. WebGL playground

   This is a great resource to see WebGL code in action and play live with the code

8. CSS Transitions

   The smoothness of this page is very much the result of using CSS transitions. Check the docs to learn all about them.

   You can also see it in action here.

9. Gamepad API

   Gamepad and joystick support is coming to Firefox and Chrome.

   You can also see it in action here.

10. HTML parsing in JavaScript

    “Next time you shout at some browser for doing it wrong

    You can also see it in action here.

11. Popcorn.js

    Popcorn is a Mozilla sponsored project to make it dead easy to sync media with web content.

    You can also see it in action here.

12. WebGL Walker

    A cool and customizable skeleton done with WebGL. I recommend maxing out the sliders!

    You can also see it in action here.

13. Context menus in browsers

    This is a jQuery polyfill to bring native context menus as supported in Firefox 8+ to all browsers.

    You can also see it in action here.

14. Going Fullscreen with Canvas

    Nice and simple example how you can utilize the Fullscreen API to create a complete full-screen canvas experience.

    You can also see it in action here.

15. Natural Object-Rotation with CSS3 3D

    Great article on CSS 3D Transforms with beautiful illustrations. Make sure to use the various web browser prefixes in your CSS code to make it work for as many as possible.

    You can also see it in action here.

16. The Open Web platform: Browser technologies

    The Open Web is filled with technologies and specifications that offers web developers a lot of choices. This page is an overview of all those technologies.

17. Encode JavaScript as Japanese emoticons

    This is wild but it also shows that when it comes to filtering out your data for malicious injections looking for alert() doesn’t cut it.

18. Node.js

    “Node.js lets you to run JavaScript outside of the browser while utilising the full power of your computer. It allows for a whole variety of use-cases; like game and Web servers or simple applications that scrape and manipulate data.

    You can also see it in action here.

19. HTML5 Sticky Thing

    Nice canvas example which shows a playful example of you you can add nice interaction to a cute feature.

    You can also see it in action here.

20. Mouse Lock API

    The Mouse Lock API allows you to lock the position of the mouse and hide the cursor. It is perfect for games and visualisations where you need to look around a 3D world and don’t want to be restricted by traditional mouse movement on the Web.

21. Learning three.js

    Learn how to use the three.js WebGL library to create animations and games.

22. Dochub.io

    This is a great find-as-you-type interface to the MDN CSS documentation

23. HTML5 audio in games

    A small trick to fight the latency of HTML5 audio in Games

24. Video Subtitling and WebVTT

    A great introduction by the HTML5 Doctor on a very important part of online video.

My intention is to cross-compile FreeType using the Android NDK into a static library that can ultimately be used by libRocket for font rendering in HTML+CSS based UIs in OpenGL applications. I’m using the CMake build system for cross-platform builds and the android-cmake project to create a CMake toolchain for the NDK. This requires creating a CMakeLists.txt for FreeType as it doesn’t currently provide one.

The CMakeLists.txt file included below is based on the FreeType-2.4.8 release and is a result of converting the Jamfile and Makefile to CMake. Its intention is simply to allow compilation with CMake. For standard build and installs I would recommend following the instructions in the docs/INSTALL file from the FreeType directory. Note: This file will try and build *all* of FreeType2′s modules as defined in include/freetype/config/ftmodule.h. If you don’t want to build some of these modules please edit that file and remove the macro calls.This is a rather brute force method that will compile all the files and modules that are in the default build settings for FreeType. I spent some time trying to add proper CMake style options for each module that also checks their dependencies but didn’t get too far. You will need to remove files from compilation as needed.

cmake_minimum_required(VERSION 2.6)

project(FreeType2)

# First, compiler definitions for building the library
add_definitions(-DFT2_BUILD_LIBRARY)
add_definitions("-DFT_CONFIG_MODULES_H=<ftmodule.h>")

# Specify library include directories
include_directories("${PROJECT_SOURCE_DIR}/builds/ansi")
include_directories("${PROJECT_SOURCE_DIR}/include")
include_directories("${PROJECT_SOURCE_DIR}/include/freetype")
#include_directories("${PROJECT_SOURCE_DIR}/include/freetype/config")

# For the auto-generated ftmodule.h file
include_directories("${PROJECT_BINARY_DIR}/include")

include_directories("${PROJECT_SOURCE_DIR}/objs")

#file(GLOB BASE_SRCS "src/base/*.c")

set(BASE_SRCS
    src/base/ftsystem.c
    src/base/ftdebug.c
    src/base/ftinit.c
    src/base/ftbbox.c
    src/base/ftbitmap.c
    src/base/ftcid.c
    src/base/ftadvanc.c
    src/base/ftcalc.c
    src/base/ftdbgmem.c
    src/base/ftgloadr.c
    src/base/ftobjs.c
    src/base/ftoutln.c
    src/base/ftrfork.c
    src/base/ftsnames.c
    src/base/ftstream.c
    src/base/fttrigon.c
    src/base/ftutil.c
    src/base/ftfstype.c
    src/base/ftgasp.c
    src/base/ftglyph.c
    src/base/ftgxval.c
    src/base/ftlcdfil.c
    src/base/ftmm.c
    src/base/ftotval.c
    src/base/ftpatent.c
    src/base/ftpfr.c
    src/base/ftstroke.c
    src/base/ftsynth.c
    src/base/fttype1.c
    src/base/ftwinfnt.c
    src/base/ftxf86.c
    src/truetype/truetype.c
    src/type1/type1.c
    src/cff/cff.c
    src/cid/type1cid.c
    src/pfr/pfr.c
    src/type42/type42.c
    src/winfonts/winfnt.c
    src/pcf/pcf.c
    src/bdf/bdf.c
    src/sfnt/sfnt.c
    src/autofit/autofit.c
    src/pshinter/pshinter.c
    src/raster/raster.c
    src/smooth/smooth.c
    src/cache/ftcache.c
    src/gzip/ftgzip.c
    src/lzw/ftlzw.c
    src/bzip2/ftbzip2.c
    src/psaux/psaux.c
    src/psnames/psmodule.c)

include_directories("src/truetype")
include_directories("src/sfnt")
include_directories("src/autofit")
include_directories("src/smooth")
include_directories("src/raster")
include_directories("src/psaux")
include_directories("src/psnames")

add_library(freetype SHARED ${BASE_SRCS})

set(FREETYPE_LIBRARY freetype CACHE STRING "The FreeType library name")
set(FREETYPE_FOUND TRUE CACHE BOOL "Whether freetype has been found or not")
set(FREETYPE_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/include/
    ${PROJECT_SOURCE_DIR}/include/freetype CACHE STRING "FreeType include
    directories")

    set(FREETYPE_INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/include/
    ${PROJECT_SOURCE_DIR}/include/freetype CACHE STRING "FreeType include
    directories")

The file sets the variables that FindFreeType.cmake sets, so any dependent sub-projects should use this first. Just remember to use:

# Build FreeType
add_subdirectory(lib/freetype-2.4.8)
include_directories(lib/freetype-2.4.8/include)

… before building the dependent projects.

Version 1.47 adds some useful modules such as Boost::Random and Boost::Asio, but the patches from 1.45 don’t apply. Luckily klayge.org has applied the patches manually (there aren’t many).

Patching Boost:

• The patched Boost 1.47 files here.
• The Boost 1.47 source here.
• android-cmake installed and configured to use your NDK toolchain.

First, merge (don’t replace!) the boost and libs folders from the download into the boost directory. You now have a patched version of Boost. Paste the contents of the code below into a file called CMakeLists.txt inside the boost directory. This is a modified version of android-cmake’s Boost installation script that allows you to either build and install Boost to your NDK directory or build it as a dependency for a project (this has the advantage of being sure you’re using the same version of Boost on each machine you build on and for each architecture, as well as meaning you don’t need to manually install Boost on each development machine, but Boost is a very large dependency to add and it is a lot of files to place into a repository).

cmake_minimum_required(VERSION 2.8)

project(android-boost)

#find patched boost directory
set(BOOST_ROOT ${PROJECT_SOURCE_DIR} CACHE PATH  "Boost 1.47.0 patched for android")

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}  -DNO_BZIP2" )
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNO_BZIP2")

include_directories(${PROJECT_SOURCE_DIR})

# Build each of the Boost libraries that have compiled components
file(GLOB lib_srcs ${PROJECT_SOURCE_DIR}/libs/system/src/*.cpp)

add_library( boost_system ${lib_srcs})

file(GLOB lib_srcs ${PROJECT_SOURCE_DIR}/libs/filesystem/v2/src/*.cpp)

add_library( boost_filesystem ${lib_srcs})

set(lib_dir ${PROJECT_SOURCE_DIR}/libs/iostreams/src)
set(lib_srcs ${lib_dir}/file_descriptor.cpp   ${lib_dir}/gzip.cpp   ${lib_dir}/mapped_file.cpp   ${lib_dir}/zlib.cpp)
add_library( boost_iostreams ${lib_srcs})

file(GLOB lib_srcs ${PROJECT_SOURCE_DIR}/libs/program_options/src/*.cpp)

add_library( boost_program_options ${lib_srcs})

file(GLOB lib_srcs ${PROJECT_SOURCE_DIR}/libs/regex/src/*.cpp)

add_library( boost_regex ${lib_srcs})

file(GLOB lib_srcs ${PROJECT_SOURCE_DIR}/libs/signals/src/*.cpp)

add_library( boost_signals ${lib_srcs})

file(GLOB lib_srcs ${PROJECT_SOURCE_DIR}/libs/thread/src/pthread/*.cpp)

add_library( boost_thread ${lib_srcs})

set(BOOST_ROOT ${PROJECT_SOURCE_DIR} CACHE PATH "Path to the Boost root directory")
set(BOOST_INCLUDEDIR ${BOOST_ROOT} CACHE PATH "Boost include directory")
set(Boost_INCLUDE_DIRS ${BOOST_ROOT} CACHE PATH "Boost header locations")
set(Boost_LIBRARIES boost_filesystem boost_system boost_program_options
boost_iostreams boost_regex boost_signals boost_thread  CACHE STRING "khkh")

configure_file(${PROJECT_SOURCE_DIR}/BoostConfig.cmake.in
${PROJECT_BINARY_DIR}/BoostConfig.cmake @ONLY)

install(DIRECTORY ${BOOST_ROOT}/boost DESTINATION ${CMAKE_INSTALL_PREFIX}/include)
install(TARGETS boost_system DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
install(TARGETS boost_filesystem DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
install(TARGETS boost_program_options DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
install(TARGETS boost_iostreams DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
install(TARGETS boost_regex DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
install(TARGETS boost_signals DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
install(TARGETS boost_thread DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)

Optional: You can then also add Boost 1.47′s version number to the known versions in FindBoost.cmake (Boost 1.47 is newer than CMake 2.8 that I am using):

  set(_Boost_KNOWN_VERSIONS ${Boost_ADDITIONAL_VERSIONS}
    "1.47.0" "1.47" "1.46.0" "1.46" "1.45.0" "1.45" "1.44.0" "1.44" "1.43.0" "1.43" "1.42.0" "1.42"

Option: Building Boost for the NDK

You can then either open a terminal and build Boost using android-cmake and install to the NDK directory:

$ cd boost_1_47/
$ mkdir build
$ cd build/
$ android-cmake ..
$ make
$ sudo make install

Boost should now be able to be found by CMake with the standard find_package command:

find_package(Boost 1.47 COMPONENTS filesystem system thread REQUIRED)

Alternative: Adding Boost as a sub-project in CMake

If you move the boost directory into your third party library directory you can then build boost and be sure you have the correct version all of the time by adding this to your project’s CMakeLists.txt file:

# Build boost 1.47
add_subdirectory(lib/boost_1_47)

Just remember to link against ${Boost_LIBRARIES} and include ${Boost_INCLUDE_DIRS} as you usually would.

So, summary of the video:

• Surface is the name for the buffer that objects are rendered into, whether on-screen or off-screen.
• 05:23: PixelFlinger is the equivalent of a JIT for the software implementation of OpenGL that’s used in the Android emulator. This is pretty interesting, it generates assembly code at runtime based on what render operations you’re performing.
• 06:00: Views are the basic UI components, for instance each of the UI widgets inherits from View. ViewGroups contain zero or more views and provide the base class for layouts and view containers, allowing you to modify the contents of the container and set properties for how the view children are displayed. SurfaceViews are special Views that allow you to place Surfaces at certain points in the screen. Android also provides classes such as the GLSurfaceView which enables OpenGL to render into the Surface and the VideoView which allows videos to be rendered as well as providing video playback controls.
• 06:40 Applications can render via a Canvas (which uses Google’s Skia library) or via RenderScript (which currently makes OpenGL calls) or via OpenGL directly. Each rendering method eventually renders onto the specified kind of Surface.
• 07:25 Android supports OpenGL ES 1.x and 2.0, and you can use either of these on a device that supports it, early devices and devices running versions before Android 2.2 will not support OpenGL ES 2.0 – see here for a list of devices that support each version. If you are using the Android Emulator then you will be using PixelFlinger which only supports OpenGL ES 1.x.
• 08:15 Whenever a frame is drawn, SurfaceFlinger produces a composite from each visible View and renders them to a Surface (frame buffer) via either OpenGL or PixelFlinger depending on whether the software GL implementation is being used or not. Older devices used a 2D blitter called MDP.
•  09:20 Android won’t redraw a View unless it’s both visible and flagged (‘dirty’) by calling it’s invalidate() method. This invalidate call will propagate up to any ViewGroups in the view hierarchy to the ViewRoot which will lock the Surface of the window and then call draw() on all of it’s children. When that’s done the ViewRoot will unlock the canvas and swap the buffers. All windows on Android are double buffered.
• 15:00 Demo from Chet about how to add animations and effects on Views. Animations can be used for subtle indications – for instance to indicate whether an image is selected or not it’s nice to have an animation/transitioning effect rather than an abrupt change in the UI.
• 16:56 Unlike Java2D, Android’s Canvas is virtually stateless and uses Paints to specify font size, text colour, colour, opacity, filtering, dithering, anti-aliasing etc. These objects contain a lot of state information and are therefore fairly heavy-weight. Making a new Paint object every frame is not a good idea as you will soon saturate the heap and cause Garbage Collection.
• 18:15 Shaders specify how to draw horizontal or vertical spans of colours (for example different kinds of gradients), i.e. how to fill a shape. These are not the same as GLSL shaders. ComposeShader will blend two shaders together and fill the shape with that. ColorFilters perform operations on each pixel they are applied to.
• 21:00 XferModes or blending modes such as Porter-Duff (scientists who defined 12 equations that explain how transparency affects colours) and Darken, Lighten, Multiply and Screen allow modifying the colours of a Canvas. For instance, a BitmapShader and a LinearGradient can be combined with a ComposeShader to draw a bitmap that fades out.
• 23:17 Demo from Chet showing some example code for using creating new Bitmaps that arise from applying Shaders on Bitmaps. Shaders are created and then the Paint object is told to use that shader. You can then simply draw a rectangle to the screen using the specified Paint and it will perform the shader operations you specified on that rectangle.
• 25:00 Bitmaps are either mutable or immutable and have the concept of resolution. Android allows you to specify different assets for different screen resolutions in the same package, and if you place a drawable in the medium resolution folder and are running on a phone which reports itself as high resolution, Android will use that information to scale the Bitmap automatically when it is displayed. Bitmaps can be large objects so they can be recycled without having to wait for the garbage collector. Supported Bitmap formats are ALPHA_8 (for alpha masks), ARGB_4444 (this isn’t recommended, uses 4 bits for each component and therefore doesn’t look very good), ARGB_8888 (recommended, 32 bit images, allows for transparency), and RGB_565 (doesn’t contain alpha channel, limited precision for colours, faster to draw, uses dithering). JPEG images do not contain transparency and pre-Gingerbread were loaded automatically with RGB_565. This meant that jpg images automatically lost some quality pre-gingerbread. Post Gingerbread all images are loaded by default as ARGB_8888 (and application memory usage limits are increased to compensate). When loading a Bitmap, make sure to specify the format that you want, otherwise it will be loaded as it’s default and every time the Bitmap is drawn it will need to be converted. For instance, pre-Gingerbread the default bit depth for a Surface is 16 bits, so a 32 bit image will need to be converted before rendering which can be slow. You can control quality of this rendering by enabling/disabling dithering on the Paint object and the Drawable object that the Bitmap’s being used by. Blending should be avoided with the alpha channel. If Android detects an image is completely opaque it can perform a faster rendering pass.
• 30:00 Demo by Romain showing the effects of precision loss when rendering 32 bit images onto a 16 bit window (introduces artefacts, gradients look banded). Enabling dithering removes the banding somewhat and improves the gradient. Using a 32 bit window ARGB_8888 with no dithering looks fine while ARGB_4444 still looks bad (and hence isn’t recommended anywhere).
• 33:10 Slide showing performance comparisons for different bitmap image types on different surfaces. Drawing an ARGB_8888 surface is three times faster on a 32 bit surface than a 16 bit surface. ARGB_4444 is slightly faster than ARGB_8888 on a 16 bit surface. RGB_565 is 12 times faster than ARGB_8888 and 8 times faster than ARGB_4444 when rendering to a 16 bit surface (as it’s essentially a memcpy on a 16 bit surface) but three times slower than ARGB_8888 and almost twice as slow as ARGB_4444 on a 32 bit surface.
• 35:50 Demo of two different ways to copy a View into a Bitmap.
• 37:30 Chet takes over, talks about Animations. Animations enable better user experiences and can help users use the application, especially on smaller screens. The current (as of the talk) SDK has an animation superclass which controls timing, repetition, interpolation and ending states. Nonlinear interpolation on animations such as view sliding is important as it looks much better than linear motion.
• 40:30 Android allows for Transforming operations (translation, rotation, scale), Fading, Sequences (allowing you to choreograph multiple animations), Cross-fading, and Layout animations (ViewGroups can animate the display of their children via animations rather than displaying them instantly).
• 41:40 Animations are about making things look animated rather than actually being animated. This means that moving views via animations doesn’t actually move the view. If you move a button, you need to move the actual object afterwards to ensure that it will handle input events for the correct position. This is because the ViewGroup, when rendering it’s children, detects first if an animation is playing on the child before rendering it. If it is, it renders the current state of the animation rather then the View’s original settings.
• 43:16 Fading is done by interpolating alpha values, which again is not the transparency of the View, but the transparency that the View will be drawn with (see previous point).
• 45:30 Layout animations are based on staggering some template animation for each child of the view.
• 46:50 With animations you can setDrawingCacheEnabled(True) to allow the animation to represent itself as a Bitmap which means that the animated object doesn’t need to be re-rendered each frame. This is a large performance increase and is used in Android everywhere transparently. As soon as a finger touches a view (for example a ScrollView) each of the Views in the ViewGroup are transformed into Bitmaps via setDrawingCacheEnabled which allows them to be scrolled quickly without having to re-render them. When a Bitmap is off the screen it can be recycled and used by another View.
• You can follow Romain Guy at @romainguy and curious-creature.org.
• You can follow Chet Haase at @chethaase and graphics-geek.blogspot.com.

$ git sta<tab><tab>
stage    stash    status

I’ve added it to my dotfiles repository on GitHub, or you can access the latest file in the git release tarball at contrib/completion/git-completion.bash.

I’ve been storing compressed project assets using PhysicsFS, which allows for direct read/write access to compressed files such as zip files. After a little fiddling, I produced the class below that allows LibRocket to read it’s assets via PhysicsFS.

RocketFileSystemInterface.h:

#ifndef _ROCKETFILESYSTEMINTERFACE_H_
#define _ROCKETFILESYSTEMINTERFACE_H_

#include <Rocket/Core/FileInterface.h>

/**
 * A FileInterface for libRocket (http://librocket.com/) that enables the
 * reading of files via PhysicsFS (http://icculus.org/physfs/) directly from a
 * compressed archive.
 *
 * Note: The PhysicsFS system must be initialised before this class is used via
 * PHYSFS_init() and any archives must be made searchable via
 * PHYSFS_addToSearchPath().
 *
 * Author: Martin Foot
 * Date: 4th September 2011
 */
namespace Delta {
class RocketFileSystemInterface : public Rocket::Core::FileInterface {
    public:
        RocketFileSystemInterface();
        ~RocketFileSystemInterface();

        /**
         * Get a read only filehandle to the specified file.
         * @param path  The filename in the compressed archive.
         * @return A Rocket filehandle to the opened file. This can be NULL on
         * failure.
         */
        Rocket::Core::FileHandle Open(const Rocket::Core::String& path);

        /**
         * Close a previously opened file.
         * @param file  The Rocket filehandle to close.
         */
        void Close(Rocket::Core::FileHandle file);

        /**
         * Attempt to read the specified number of bytes into the provided
         * buffer. If the specified number of bytes is greater than the size of
         * the file, only  bytes will be copied.
         * @param buffer    The buffer to read into.
         * @param size  The number of bytes to read.
         * @param file  The Rocket filehandle.
         * @return  The actual number of bytes that was read into the buffer.
         */
        size_t Read(void* buffer, size_t size, Rocket::Core::FileHandle file);

        /**
         * Seek to a point in the previously opened file.
         * @param file  The Rocket filehandle.
         * @param offset    The number of bytes to seek to relative to the
         * supplied origin.
         * @param   One of SEEK_SET (seek relative to the beginning of the file),
         * SEEK_CUR (seek relative to the current position in the file) or
         * SEEK_END (relative to the end of the file).
         * @return  Whether seeking was a success or not.
         */
        bool Seek(Rocket::Core::FileHandle file, long offset, int origin);

        /**
         * Get the length of the file.
         * @param file  The Rocket filehandle.
         * @return  The size in bytes of the file.
         */
        size_t Length(Rocket::Core::FileHandle file);

        /**
         * Get the current read pointer offset.
         * @param file  The Rocket filehandle.
         * @return  The current offset. Returns 0 on failure.
         */
        size_t Tell(Rocket::Core::FileHandle file);
    };
}

#endif // _ROCKETFILESYSTEMINTERFACE_H_

RocketFileSystemInterface.cpp:

#include "RocketFileSystemInterface.h"

#include <Rocket/Core.h>
#include <Rocket/Core/Types.h>
#include <physfs.h>
#include <cstdio>
#include <string>

#include "FileSystemInterface.h"

using Delta::FileSystemInterface;

namespace Delta {

RocketFileSystemInterface::RocketFileSystemInterface() : FileInterface() {};

RocketFileSystemInterface::~RocketFileSystemInterface() {};

Rocket::Core::FileHandle RocketFileSystemInterface::Open(const Rocket::Core::String& path) {
    if (!PHYSFS_exists(path.CString())) {
        return NULL;
    }

    PHYSFS_file* file = PHYSFS_openRead(path.CString());
    return static_cast<PHYSFS_file*>((uintptr_t)file);
}

void RocketFileSystemInterface::Close(Rocket::Core::FileHandle file) {
    PHYSFS_close(static_cast<PHYSFS_file*>((void *)file));
}

size_t RocketFileSystemInterface::Read(void* buffer, size_t size, Rocket::Core::FileHandle file) {
    PHYSFS_file* ptr = static_cast<PHYSFS_file*>((void *) file);

    // Don't read past the end of the file or PhysicsFS will return an error.
    size_t length = PHYSFS_fileLength(ptr);
    if(size > length) {
        size = length;
    }

    size_t read = PHYSFS_read(ptr, buffer, size, 1);

    return read * size;
}

bool RocketFileSystemInterface::Seek(Rocket::Core::FileHandle file, long offset, int origin) {
    PHYSFS_file* ptr = static_cast<PHYSFS_file*>((void *)file);

    int response = 0;

    switch(origin) {
        case SEEK_SET:
            // Seek from the beginning of the file.
            response = PHYSFS_seek(ptr, offset);
            break;
        case SEEK_CUR:
            // Offset from the current position.
            response = PHYSFS_seek(ptr, offset + PHYSFS_tell(ptr));
            break;
        case SEEK_END:
            response = PHYSFS_seek(ptr, PHYSFS_fileLength(ptr));
            break;
    }

    if(response == 0)
        return false;

    return true;
}

size_t RocketFileSystemInterface::Tell(Rocket::Core::FileHandle file) {
    PHYSFS_file* ptr = static_cast<PHYSFS_file*>((void *)file);
    size_t offset = PHYSFS_tell(ptr);
    return offset;
}

size_t RocketFileSystemInterface::Length(Rocket::Core::FileHandle file) {
    PHYSFS_file* ptr = static_cast<PHYSFS_file*>((void *)file);
    return PHYSFS_fileLength(ptr);
}

}

The solution uses a slightly modified version of this example for Android that uses this Java Base64 encode/decode class. The Python script is based on an example by Jon Berg.

The Python web server is below:

#!/usr/bin/env python

import cgi
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer

class MyHandler(BaseHTTPRequestHandler):

    def do_GET(self):
        print "Somebody made a POST request."
        return

    def do_POST(self):
        """
        Take the Base64 encoded string that the phone transmit, decode it and
        save it as an image file called phone.jpg.
        """
        global rootnode
        try:
            ctype, pdict = cgi.parse_header(self.headers.getheader('content-type'))
            print ctype
            print pdict
            if ctype == 'multipart/form-data':
                query=cgi.parse_multipart(self.rfile, pdict)
            elif ctype == 'application/x-www-form-urlencoded':
                length = int(self.headers.getheader('content-length'))
                query = cgi.parse_qs(self.rfile.read(length), keep_blank_values=1)

            self.send_response(301)
            self.send_header('Content-type', 'text/html')
            self.end_headers()

            upfilecontent = query.get('upfile')
            self.wfile.write("POST OK.

");
            f = open("phone.jpg", "wb")
            f.write(upfilecontent[0].decode('base64'))
            f.close()
            print("File received.")

            return
        except Exception, err:
            print Exception, err
            pass

def main():
    try:
        server = HTTPServer(('', 8000), MyHandler)
        print 'started httpserver...'
        server.serve_forever()
    except KeyboardInterrupt:
        print '^C received, shutting down server'
        server.socket.close()

if __name__ == '__main__':
    main()

And here’s the Android Activity (remember to add the CAMERA permission to your manifest and add the above linked Base64 encoding class to your workspace and package).

package com.elec6024.eardetection;

/**
 * This Android Activity takes a photo and uploads it to a server.
 * The server upload HTTP POST code is modified from this:
 * http://coderzheaven.com/index.php/2011/04/android-upload-an-image-to-a-server/
 */
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Bundle;
import android.os.Environment;
import android.provider.MediaStore;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends Activity
{
	private Uri outputFileUri;
	private InputStream inputStream;
	public static final int PICTURE_ACTIVITY = 35434;

    /* Override the onCreate method */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);
		final Button cameraButton = (Button)findViewById(R.id.camera_button);
		cameraButton.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v){
				// Check if there's external storage available and that it's writeable.
				boolean mExternalStorageAvailable = false;
				boolean mExternalStorageWriteable = false;
				String state = Environment.getExternalStorageState();

				if (Environment.MEDIA_MOUNTED.equals(state)) {
				    // We can read and write the media
				    mExternalStorageAvailable = mExternalStorageWriteable = true;
				} else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
				    // We can only read the media
				    mExternalStorageAvailable = true;
				    mExternalStorageWriteable = false;
				} else {
				    // Something else is wrong. It may be one of many other states, but all we need
				    //  to know is we can neither read nor write
				    mExternalStorageAvailable = mExternalStorageWriteable = false;
				}

				if(mExternalStorageAvailable && mExternalStorageWriteable){
					Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); // Normally you would populate this with your custom intent.
					File file = new File(Environment.getExternalStorageDirectory(),"imagefile.jpg");
					outputFileUri = Uri.fromFile(file);
					cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
					startActivityForResult(cameraIntent, PICTURE_ACTIVITY);
				}
			}
		});
    }

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
		super.onActivityResult(requestCode, resultCode, intent);

		if (requestCode == PICTURE_ACTIVITY && resultCode == Activity.RESULT_OK) {

			File file = new File(Environment.getExternalStorageDirectory(),"imagefile.jpg");
			if(file.exists()){
				ByteArrayOutputStream stream = new ByteArrayOutputStream();

				// Enclose this in a scope so that when it's over we can call the garbage collector (the phone doesn't have a lot of memory!)
				{
					Bitmap image = BitmapFactory.decodeFile(file.getPath());
					Bitmap scaled = Bitmap.createScaledBitmap(image, (int)(image.getWidth() * 0.3), (int)(image.getHeight() * 0.3), false);
					scaled.compress(Bitmap.CompressFormat.JPEG, 90, stream);
				}

				System.gc();

			    byte [] byte_arr = stream.toByteArray();
			    String image_str = Base64.encodeBytes(byte_arr);
			    ArrayList nameValuePairs = new ArrayList();

			    nameValuePairs.add(new BasicNameValuePair("upfile",image_str));

			    try {
			        HttpClient httpclient = new DefaultHttpClient();
			        final String URL = "http://192.168.2.3:8000";
			        HttpPost httppost = new HttpPost(URL);
			        httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
			        HttpResponse response = httpclient.execute(httppost);
			        String the_string_response = convertResponseToString(response);
			        Toast.makeText(MainActivity.this, "Response " + the_string_response, Toast.LENGTH_LONG).show();
			    } catch(Exception e){
			          Toast.makeText(MainActivity
			        		  .this, "ERROR " + e.getMessage(), Toast.LENGTH_LONG).show();
			          System.out.println("Error in http connection "+e.toString());
			          e.printStackTrace();
			    }
			}
		}
	}

    public String convertResponseToString(HttpResponse response) throws IllegalStateException, IOException{
        String res = "";
        StringBuffer buffer = new StringBuffer();
        inputStream = response.getEntity().getContent();
        int contentLength = (int) response.getEntity().getContentLength(); //getting content length…..
	        Toast.makeText(MainActivity.this, "contentLength : " + contentLength, Toast.LENGTH_LONG).show();
        if (contentLength < 0){         }         else{                byte[] data = new byte[512];                int len = 0;                try                {                    while (-1 != (len = inputStream.read(data)) )                    {                        buffer.append(new String(data, 0, len)); //converting to string and appending  to stringbuffer…..                    }                }                catch (IOException e)                {                    e.printStackTrace();                }                try                {                    inputStream.close(); // closing the stream…..                }                catch (IOException e)                {                    e.printStackTrace();                }                res = buffer.toString();     // converting stringbuffer to string…..                Toast.makeText(MainActivity.this, "Result : " + res, Toast.LENGTH_LONG).show();                //System.out.println("Response => " +  EntityUtils.toString(response.getEntity()));
        }
        return res;
   }
}

You’ll also need the layout file for the application:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
    <ImageView android:layout_weight="2"
        android:id="@+id/imageview"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent" />
    <Button
	android:id="@+id/camera_button"
	android:layout_weight="1"
	android:layout_width="fill_parent"
	android:layout_height="wrap_content"
	android:text="@string/camera_button_text"
	android:textSize="@dimen/big_text"/>
</LinearLayout>

CMake is a build system that makes it incredibly easy to distribute and compile source code packages on multiple platforms. It will automatically scan dependencies, searching in the correct (for standard installs) places for each platform and warning if they are not met. Once it has calculated what’s necessary to build the project it can generate build scripts and project files for several popular IDEs including Eclipse, XCode, Unix Makefiles, and Visual Studio (read their about page to learn more).

CMake with Doxygen

As well as building your source, CMake can also run Doxygen to generate documentation after a build. Here’s a sample that I use based on the example here:

################################################################################
# Documentation Generation
#
# Build documentation using Doxygen (www.doxygen.org)
# Builds the docs in the docs/ directory (HTML and LaTeX formats for a .pdf)
################################################################################
find_package(Doxygen)

if(DOXYGEN_FOUND)
    configure_file(${PROJECT_SOURCE_DIR}/doc/Doxyfile.in ${PROJECT_SOURCE_DIR}/doc/Doxyfile @ONLY)
    add_custom_target(doc ALL ${DOXYGEN_EXECUTABLE} ${PROJECT_SOURCE_DIR}/doc/Doxyfile  COMMENT "Generating API documentation with Doxygen" VERBATIM)
endif(DOXYGEN_FOUND)

This will take a file called Doxyfile.in (rename your Doxyfile if you’re just getting started) and substitute any values that you’ve specified into the file. This means that by changing a variable in the CMakeLists.txt you can have that change show up in your documentation. Inside the Doxyfile.in file you can specify things like this:

PROJECT_NAME = "@PROJECT_NAME@"
PROJECT_NUMBER = "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@"
PROJECT_LOGO = @CMAKE_CURRENT_SOURCE_DIR@/assets/project_logo.png
OUTPUT_DIRECTORY = @CMAKE_CURRENT_BINARY_DIR@/doc
INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@/src @CMAKE_CURRENT_SOURCE_DIR@/test/src @CMAKE_CURRENT_SOURCE_DIR@/src/Core.h.in
EXAMPLE_PATH = @CMAKE_CURRENT_SOURCE_DIR@/examples
IMAGE_PATH = @CMAKE_CURRENT_SOURCE_DIR@/assets

CMake and CTest with Google C++ Testing Framework

CMake makes it very easy to add other projects that use CMake to the build as a dependency. Google’s C++ Testing Framework provides a CMakeLists.txt, so all you need to do in order to add gtest to your project is point your CMakeLists.txt to the gtest folder. Mine’s in the ‘lib’ folder:

################################################################################
# Testing
#
# Build GTest (See http://code.google.com/p/googletest/)
# Run different GTest test programs.
################################################################################

enable_testing(true)

# Build GTest
add_subdirectory(lib/gtest-1.6.0)

include_directories(${gtest_SOURCE_DIR} ${gtest_SOURCE_DIR}/include)

# Compile the test sources.
add_executable(runTests test/src/test.cpp)

# Link the test sources to the gtest libraries.
target_link_libraries(runTests ${LIB} gtest gtest_main)

# Add that executable to the CTests testing framework.
add_test(
    FixedSizeArrayTests runTests
)

The only problem here is that while in GTest you don’t need to enumerate each file, using CMake’s CTest facility you will do. This could be fixed by defining a simple macro that will add all the tests in a folder. This is a good starting point. The above code will enable the ‘test’ build target in the Makefile.

In addition, gtest provides the option to output it’s test results to JUnit-compliant XML files. In order to do this you need to have a minimum of CMake version 2.8 (so set cmake_minimum_required(VERSION 2.8)) and then you can set the CTest environment variable “xml” like this:

set_tests_properties(FixedSizeArrayTests PROPERTIES ENVIRONMENT "GTEST_OUTPUT=xml")

This is especially useful if you’re using a build system such as Jenkins (if so, be sure to look at the CMakebuilder plugin) as you can set Jenkins to perform testing and then display JUnit test results with each build.

 If you’re running Linux, it will attempt to set the Gnome background wallpaper to the downloaded image, and by default it downloads to ~/Dropbox/Wallpapers. This can be changed by modifying the DOWNLOAD_FOLDER variable. The bonus of it downloading to Dropbox is that I can run the script in a cron job on my Linux desktop and have the wallpapers appear on all my other machines — especially nice as my laptop displays wallpapers randomly from the Wallpapers folder.

#!/usr/bin/env python

"""
natgeowp.py

Fetches the National Geographic Photo of the Day from the @NatGeo Twitter
stream, downloads it, and tries to set it as the background wallpaper.

Can be scheduled to run in a cron job with crontab.

Martin Foot <martin@mfoot.com>

This is a cleaned up version of my original script after seeing Christian
Stefanescu's NASA image of the day wallpaper script -

http://0chris.com/nasa-image-day-script-python.html

"""

try:
    from urllib.request import urlopen
except ImportError:
    # We're using Python 2.x, not Python 3.x
    from urllib import urlopen

import json
import re
import os
import commands
import platform

# Configurable settings
FEED_URL = 'http://twitter.com/statuses/user_timeline.json?id=NatGeo'
DOWNLOAD_FOLDER = os.path.join(os.getenv('HOME'), 'Dropbox', 'Wallpapers')

def fetch_tweets(feed_url):
    """
    Return JSON object of the Twitter stream.
    """
    # Don't edit below
    twitter = urlopen(feed_url)
    tweets = twitter.read()
    twitter.close()
    tweets = json.loads(tweets)
    return tweets

def filter_tweets(haystack):
    """
    Filter out any tweets that don't contain the words "Photo of the Day"
    """
    needle = 'Photo of the Day'

    found = []

    # Loop through tweets, newest last.
    for tweet in haystack:
        if tweet['text'].startswith(needle):
            # We've found a photo, extract the URL (tweet seems to be
            # automated, we can assume there will be one).
            pic_url = re.search("(http://\S+)", tweet['text'])#.groups()[0]

            if pic_url != None:
                pic_url = pic_url.groups()[0]
                found.append(pic_url)

    return found

def check_downloadable(urls):
    """
    Loop through a list of National Geographic Photo of the Day URLs, and if
    they provide a download link, record it. Some images such as
    reader-submitted images don't provide a link, likely due to licensing
    issues. We won't download these.
    """
    found = []

    for pic_url in urls:
        text = str(urlopen(pic_url).read())
        pic_url = re.search('a href="(\S+)">Download Wallpaper', text)

        # Not all photos have a download link
        if pic_url != None:
            pic_url = pic_url.groups()[0]

            found.append(pic_url)

    return found

def download_photos(urls):
    """
    Download the list of files to the DOWNLOAD_FOLDER directory.
    """
    for url in urls:
        print 'Downloading ' + url
        filename = re.search(".*/(.+)", url).groups()[0]
        path = os.path.join(DOWNLOAD_FOLDER, filename)

        imageFile = open(path, "wb")
        imageFile.write(urlopen(url).read())
        imageFile.close()

    return path

def set_gnome_wallpaper(file_path):
    command = "gconftool-2 --set \
            /desktop/gnome/background/picture_filename \
            --type string '%s'" % file_path
    status, output = commands.getstatusoutput(command)
    return status

if __name__ == '__main__':
    tweets = fetch_tweets(FEED_URL)
    image_urls = filter_tweets(tweets)
    downloadable_urls = check_downloadable(image_urls)

    if len(downloadable_urls) > 0:
        most_recent = download_photos(downloadable_urls)

        osplatform = platform.system()

        # If we're on Linux, try and set the desktop wallpaper with gconftool
        # (TODO: Non-Gnome desktop environments).
        if osplatform == "Linux":
            set_gnome_wallpaper(most_recent)