http://www.viemu.com/a_vi_vim_graphical_cheat_sheet_tutorial.html

https://github.com/LevelbossMike/vim_shortcut_wallpaper/

• Above is a video from HackADay about a new robot called the Sand Flea that has an impressive ability to jump over obstacles. This could be very useful for robotic exploration in areas of difficult terrain.
• A scientist has taken over 90,000 hours of video of his baby son via cameras all around the house in order to try and understand the learning of language and how we pick up and reproduce new words. I’m sure that I’ve seen a video of this before a few years ago, but now there is a lot more footage and similarly more interesting results. Read more about it including several videos here.
• The new version of Rails has been released, which among other things addresses the config.active_record.whitelist_attributes issue that lead to the GitHub compromise earlier this year.
• Ranjib Dey has an overview of the main common parts in web infrastructures.
• Nikolay Sturm describes how we can apply object oriented principles such as the single responsibility principle and object extendability to configuration management systems such as Chef.
• Nikolay was also featured on the Food Fight podcast talking about Cookbook reusability with Chef.
• Etsy have a blog post describing how their infrastructure can scale and pump out new VMs so that newly hired employees can push something to production on their first day. It’s interesting seeing which tools they use and how they use them to facilitate this.
• Netflix maintain a technical blog that describes some of the challenges they face and how they go about overcoming them. One in particular talks about fault tolerance in high volume distributed systems and is a useful read for anybody designing a service based architecture.
• John Vincent discusses requirements to be able to accurately graph dependencies at macro and micro levels in order to efficiently act upon changes in the dependency hierarchy.
• Finally, in a less educational but more entertaining capacity, I have been reading several articles each trying to clarify what DevOps really is and if/why it’s actually useful. Make what you will of the content. What DevOps is not, Ops, DevOps and PaaS (NoOps) at Netflix, and a response to that post.

Why is programming fun? What delights may its practitioner expect as a reward?

First is the sheer joy of making things. As the child delights in his mud pie, so the adult enjoys building things, especially things of his own design. I think this delight must be an image of God’s delight in making things, a delight shown in the distinctness and newness of each leaf and snowflake.

Second is the pleasure of making things that are useful to other people. Deep within, we want others to use our work and find it helpful. In this respect the programming system is not essentially different from the child’s first clay pencil holder “for Daddy’s office.”

Third is the fascination of fashioning complex puzzle-like objects of interlocking moving parts and watching them work in subtle cycles, playing out the consequences of principles built in from the beginning. The programmed computer has all the fascination of a pinball machine or the jukebox mechanism, carried to the ultimate.

Fourth is the joy of always learning, which springs from the nonrepeating nature of the task. In one way or other the problem is never new, and its solver learns something: sometimes practical, sometimes theoretical, and sometimes both.

Finally, there is the delight in working with such a tractable medium. The programmer, like the poet, works only slightly removed from pure thought-stuff. He builds his castles in the air, from the air, creating by exertion of the imagination. Few media of creation are so flexible, so easy to polish and rework, so readily capable of realizing grand conceptual structures.

Yet the program construct, unlike the poet’s words, is real in the sense that it moves and works, producing visible outputs separate from the construct itself. It prints results, draws pictures, produces sound, moves arms. The magic of myth and legend has come true in our time. One types the correct incantation on a keyboard, and a display screen comes to life, showing things that never were nor could be.

Programming then is fun because it gratifies creative longings built deep within us and delights sensibilities we have in common with all men.

1. An awesome time-lapse video of night skies was posted the other day (embedded above). I love stunning videos of nature and this is no exception.
2. Some scientists as part of a Russian research team have reportedly managed to germinate seeds that were found under 124 feet (38 meters) of permafrost (annoyingly, it doesn’t link to the source journal article), which were determined to be around 32,000 years old by radiocarbon dating. The article describes how knowledge of unfreezing and re-cultivating these seeds could benefit places such as the Svalbard Global Seed Vault.
3. A new experimental plugin for Firefox called Collision that allows you to visualise the connections between services that websites use to track you while you are online. It’s certainly quite eye-opening about the number of websites that record your usage data and statistics. Mozilla writes: Not all tracking is bad. Many services rely on user data to provide relevant content and enhance your online experience. But most tracking happens without users’ consent and without their knowledge. That’s not okay. It should be you who decides when, how and if you want to be tracked. Collusion will be a powerful tool to help you do that
4. The Raspberry Pi foundation also recently announced that they have started shipping A and B model Raspberry Pis, although they are currently out of stock in both RS and Farnell. Using these distributors allows for a much higher production rate that scales to demand, and will help reduce shipping costs for people due to worldwide distribution networks. Can’t wait until they are back in stock.
5. A scary post that describes a fish parasite that enters the gills of a fish, devours its tongue, then positions itself in place of the tongue. Just the picture alone is creepy! Nature is awesome.
6. A BBC Horizon show about what exercise really does and the best ways of getting the maximum benefit (probably UK only). This is coupled with a post from DiscoverMagazine on a new study that suggests healthy people will develop higher blood sugar after only three days of a sedentary lifestyle.
7. A post from Mark Shuttleworth that shows the new HUD functionality coming in Ubuntu 12.04.
8. A good collection of 30 books that everyone in the software business should read and why. I know that five or six of these are already on my Amazon wishlist for when I have the time, and it’s definitely a list worth looking at.
9. An interesting explanation of why the bin, sbin, usr/bin, and usr/sbin folders exist in Unix as well as why the programs located in each exist where they do.
10. A detailed and very interesting article describing Tumblr’s scalable architecture and how it allows them to serve ’500 million page views a day, a peak rate of ~40k requests per second, ~3TB of new data to store a day, all running on 1000+ servers’.

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.