RTABMapConfig.cmake: added find VTK if vtkGUISupportQt target is required

Odometry: Added additional debug information on dt>0 assert

.gitignore

@@ -0,0 +1,7 @@
+/lib
+.DS_Store
+.settings/language.settings.xml
+app/android/.classpath
+app/android/.project
+app/android/AndroidManifest.xml
+app/android/res/raw/

.travis.yml

@@ -0,0 +1,29 @@
+sudo: true
+dist: trusty
+language: cpp
+
+compiler:
+  - gcc
+  - clang
+
+addons:
+  apt:
+    packages:
+      - cmake
+      - libopencv-dev
+      - libqt4-dev
+      - libsqlite3-dev
+
+install:
+    - sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu trusty main" > /etc/apt/sources.list.d/ros-latest.list'
+    - wget http://packages.ros.org/ros.key -O - | sudo apt-key add -
+    - sudo apt-get update
+    - sudo apt-get -y install libpcl-1.7-all libfreenect-dev
+
+script: 
+    - mkdir -p build && cd build
+    - cmake .. 
+    - make
+
+notifications:
+  email: false

CMakeLists.txt

@@ -6,9 +6,10 @@ SET(PROJECT_PREFIX rtabmap)
 
 # Catkin doesn't support multiarch library path, 
 # fix to "lib" if not set by user.
-IF(NOT DEFINED CMAKE_INSTALL_LIBDIR)
+OPTION(MULTI_ARCH "Activate multi-arch lib directory (debian)" OFF)
+IF(NOT MULTI_ARCH AND NOT DEFINED CMAKE_INSTALL_LIBDIR)
    set(CMAKE_INSTALL_LIBDIR "lib")
-ENDIF(NOT DEFINED CMAKE_INSTALL_LIBDIR)
+ENDIF(NOT MULTI_ARCH AND NOT DEFINED CMAKE_INSTALL_LIBDIR)
 
 INCLUDE(GNUInstallDirs)
 
@@ -19,8 +20,8 @@ SET(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake_modules")
 # VERSION
 #######################
 SET(RTABMAP_MAJOR_VERSION 0)
-SET(RTABMAP_MINOR_VERSION 10)
-SET(RTABMAP_PATCH_VERSION 10)
+SET(RTABMAP_MINOR_VERSION 11)
+SET(RTABMAP_PATCH_VERSION 8)
 SET(RTABMAP_VERSION
   ${RTABMAP_MAJOR_VERSION}.${RTABMAP_MINOR_VERSION}.${RTABMAP_PATCH_VERSION})
   
@@ -32,8 +33,6 @@ SET(PROJECT_VERSION_PATCH ${RTABMAP_PATCH_VERSION})
 
 SET(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 
-SET(RTABMAP_QT_VERSION 4 CACHE STRING "Which QT version to use")
-
 ####### COMPILATION PARAMS #######
 # In case of Makefiles if the user does not setup CMAKE_BUILD_TYPE, assume it's Release:
 IF(${CMAKE_GENERATOR} MATCHES ".*Makefiles")
@@ -42,11 +41,13 @@ IF(${CMAKE_GENERATOR} MATCHES ".*Makefiles")
     ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
 ENDIF(${CMAKE_GENERATOR} MATCHES ".*Makefiles")
 
-SET(CMAKE_DEBUG_POSTFIX "d")
+IF(NOT ANDROID)
+    SET(CMAKE_DEBUG_POSTFIX "d")
+ENDIF(NOT ANDROID)
 
 IF(WIN32 AND NOT MINGW)
   	ADD_DEFINITIONS("-DNOMINMAX")
-    ADD_DEFINITIONS("-wd4100 -wd4127 -wd4191 -wd4242 -wd4244 -wd4251 -wd4305 -wd4365 -wd4512 -wd4514 -wd4548 -wd4571 -wd4619 -wd4625 -wd4626 -wd4628 -wd4668 -wd4710 -wd4711 -wd4738 -wd4820 -wd4946 -wd4986")
+    ADD_DEFINITIONS("-wd4100 -wd4127 -wd4150 -wd4191 -wd4242 -wd4244 -wd4251 -wd4305 -wd4365 -wd4512 -wd4514 -wd4548 -wd4571 -wd4619 -wd4625 -wd4626 -wd4628 -wd4668 -wd4710 -wd4711 -wd4738 -wd4820 -wd4946 -wd4986")
 ELSE ()
 	ADD_DEFINITIONS( "-Wall" )
 	ADD_DEFINITIONS("-Wno-unknown-pragmas")
@@ -119,6 +120,9 @@ set(INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH
 IF(APPLE)
 	OPTION(BUILD_AS_BUNDLE "Set to ON to build as bundle (DragNDrop)" OFF)
 ENDIF(APPLE)
+OPTION(BUILD_APP "Build main application" ON)
+OPTION(BUILD_TOOLS "Build tools" ON)
+OPTION(BUILD_EXAMPLES "Build examples" ON)
 
 ####### DEPENDENCIES #######
 
@@ -129,12 +133,39 @@ option(WITH_OPENNI2       "Include OpenNI2 support"              ON)
 option(WITH_DC1394        "Include dc1394 support"               ON)
 option(WITH_G2O           "Include g2o support"                  ON)
 option(WITH_GTSAM         "Include GTSAM support"                ON)
+option(WITH_TORO          "Include TORO support"                 ON)
+option(WITH_VERTIGO       "Include Vertigo support"              ON)
 option(WITH_CVSBA         "Include cvsba support"                ON)
 option(WITH_FLYCAPTURE2   "Include FlyCapture2/Triclops support" ON)
+option(WITH_ZED           "Include ZED sdk support"              ON)
+option(WITH_OCTOMAP       "Include Octomap support"              ON)
+option(PCL_OMP            "With PCL OMP implementations"         ON)
 
 FIND_PACKAGE(OpenCV REQUIRED QUIET)
 FIND_PACKAGE(PCL 1.7 REQUIRED QUIET)
 FIND_PACKAGE(ZLIB REQUIRED QUIET)
+
+# fix libproj.so not found on Xenial
+if(NOT "${PCL_LIBRARIES}" STREQUAL "")
+   list(REMOVE_ITEM PCL_LIBRARIES "vtkproj4")
+endif()
+
+# OpenMP ("-fopenmp" should be added for flann included in PCL)
+# the gcc-4.2.1 coming with MacOS X is not compatible with the OpenMP pragmas we use, so disabling OpenMP for it
+if((NOT APPLE) OR (NOT CMAKE_COMPILER_IS_GNUCXX) OR (GCC_VERSION VERSION_GREATER 4.2.1) OR (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
+  find_package(OpenMP)
+endif()
+if(OPENMP_FOUND)
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+  message (STATUS "Found OpenMP")
+  if(PCL_OMP)
+    add_definitions(-DPCL_OMP)
+  endif(PCL_OMP)
+else(OPENMP_FOUND)
+  message (STATUS "Not found OpenMP")
+endif()
+
 IF(OpenCV_FOUND)
    MESSAGE(STATUS "Found OpenCV: ${OpenCV_INCLUDE_DIRS}")
 ENDIF(OpenCV_FOUND)
@@ -145,18 +176,36 @@ IF(ZLIB_FOUND)
    MESSAGE(STATUS "Found ZLIB: ${ZLIB_INCLUDE_DIRS}")
 ENDIF(ZLIB_FOUND)
 
+SET(ADD_VTK_GUI_SUPPORT_QT_TO_CONF FALSE)
 IF(WITH_QT)
-# If Qt is here, the GUI will be built
-    IF("${RTABMAP_QT_VERSION}" STREQUAL "4")
+    FIND_PACKAGE(VTK)
+    IF(NOT VTK_FOUND)
+        MESSAGE(FATAL_ERROR "VTK is required when using Qt. Set -DWITH_QT=OFF if you don't want gui tools.")
+    ENDIF(NOT VTK_FOUND)
+
+    # If Qt is here, the GUI will be built
+    # look for Qt5 (if vtk>5 is installed) before Qt4
+    IF("${VTK_MAJOR_VERSION}" GREATER 5)
+        FIND_PACKAGE(Qt5 COMPONENTS Widgets Core Gui QUIET)
+        IF(Qt5_FOUND)
+             FIND_PACKAGE(Qt5 COMPONENTS Widgets Core Gui Svg)
+        ENDIF(Qt5_FOUND)
+    ENDIF("${VTK_MAJOR_VERSION}" GREATER 5)
+
+    IF(NOT Qt5_FOUND)
         FIND_PACKAGE(Qt4 COMPONENTS QtCore QtGui QtSvg)
-    ELSE()
-        FIND_PACKAGE(Qt5 COMPONENTS Widgets Core Gui Svg)
-    ENDIF()
+    ENDIF(NOT Qt5_FOUND)
+        
     IF(QT4_FOUND OR Qt5_FOUND)
-        FIND_PACKAGE(VTK REQUIRED)
         IF("${VTK_MAJOR_VERSION}" EQUAL 5)
             FIND_PACKAGE(QVTK REQUIRED) # only for VTK 5
-        ENDIF("${VTK_MAJOR_VERSION}" EQUAL 5)
+        ELSE()
+            list(FIND PCL_LIBRARIES vtkGUISupportQt value)
+            IF(value EQUAL -1)
+                SET(PCL_LIBRARIES "${PCL_LIBRARIES};vtkGUISupportQt")
+                SET(ADD_VTK_GUI_SUPPORT_QT_TO_CONF TRUE)
+            ENDIF(value EQUAL -1)
+        ENDIF()
     ENDIF(QT4_FOUND OR Qt5_FOUND)
 ENDIF(WITH_QT)
 
@@ -170,16 +219,20 @@ ENDIF(WITH_FREENECT)
 IF(WITH_FREENECT2)
     FIND_PACKAGE(freenect2 QUIET)
     IF(freenect2_FOUND)
+	   IF(NOT freenect2_INCLUDE_DIRS)
+	      SET(freenect2_INCLUDE_DIRS ${freenect2_INCLUDE_DIR})
+	   ENDIF(NOT freenect2_INCLUDE_DIRS)
        MESSAGE(STATUS "Found freenect2: ${freenect2_INCLUDE_DIRS}")
     ENDIF(freenect2_FOUND)
 ENDIF(WITH_FREENECT2)
 
-IF(WITH_OPENNI2)
+# IF PCL depends on OpenNI2 (already found), ignore WITH_OPENNI2
+IF(WITH_OPENNI2 OR OpenNI2_FOUND)
     FIND_PACKAGE(OpenNI2 QUIET)
     IF(OpenNI2_FOUND)
        MESSAGE(STATUS "Found OpenNI2: ${OpenNI2_INCLUDE_DIRS}")
     ENDIF(OpenNI2_FOUND)
-ENDIF(WITH_OPENNI2)
+ENDIF(WITH_OPENNI2 OR OpenNI2_FOUND)
 
 IF(WITH_DC1394)
     FIND_PACKAGE(DC1394 QUIET)
@@ -207,12 +260,64 @@ IF(WITH_FLYCAPTURE2)
 ENDIF(WITH_FLYCAPTURE2)
 
 IF(WITH_CVSBA)
-    FIND_PACKAGE(cvsba)
+	FIND_PACKAGE(cvsba QUIET)
     IF(cvsba_FOUND)
        MESSAGE(STATUS "Found cvsba: ${cvsba_INCLUDE_DIRS}")
     ENDIF(cvsba_FOUND)
 ENDIF(WITH_CVSBA)
 
+IF(WITH_ZED)
+	IF(WIN32) # Windows
+		SET(ZED_INCLUDE_DIRS $ENV{ZED_INCLUDE_DIRS})
+		if (CMAKE_CL_64) # 64 bits
+			SET(ZED_LIBRARIES $ENV{ZED_LIBRARIES_64})
+		else(CMAKE_CL_64) # 32 bits
+			message("32bits compilation is no more available with CUDA7.0")
+		endif(CMAKE_CL_64)
+		SET(ZED_LIBRARY_DIR $ENV{ZED_LIBRARY_DIR})
+		IF(ZED_LIBRARIES AND ZED_INCLUDE_DIRS)
+			SET(ZED_FOUND TRUE)
+			LINK_DIRECTORIES( ${LINK_DIRECTORIES} ${ZED_LIBRARY_DIR})
+		ENDIF(ZED_LIBRARIES AND ZED_INCLUDE_DIRS)
+	ELSE() # Linux
+		find_package(ZED 1 QUIET)
+	ENDIF(WIN32)
+	
+	IF(ZED_FOUND)
+       MESSAGE(STATUS "Found ZED sdk: ${ZED_INCLUDE_DIRS}")
+	   ## look for CUDA
+	   find_package(CUDA)
+	   IF(CUDA_FOUND)
+		MESSAGE(STATUS "Found CUDA: ${CUDA_INCLUDE_DIRS}")
+	   ELSE()
+	    MESSAGE(FATAL_ERROR "CUDA is required to build with Zed sdk! Set -DWITH_ZED=OFF if you don't have CUDA.")
+	   ENDIF()
+    ENDIF(ZED_FOUND)
+ENDIF(WITH_ZED)
+
+IF(WITH_OCTOMAP)
+	FIND_PACKAGE(OCTOMAP QUIET)
+    IF(OCTOMAP_FOUND)
+       MESSAGE(STATUS "Found octomap: ${OCTOMAP_INCLUDE_DIRS}")
+    ENDIF(OCTOMAP_FOUND)
+ENDIF(WITH_OCTOMAP)
+
+IF(G2O_FOUND OR GTSAM_FOUND OR ZED_FOUND)
+   #Newest versions require std11
+   IF(NOT MSVC)
+     include(CheckCXXCompilerFlag)
+	  CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
+	  CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
+	  IF(COMPILER_SUPPORTS_CXX11)
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+	  ELSEIF(COMPILER_SUPPORTS_CXX0X)
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+	  ELSE()
+		message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler if you want to use g2o or gtsam (set \"-DWITH_G2O=OFF -DWITH_GTSAM=OFF\" to build without g2o and gtsam).")
+	  ENDIF()
+   ENDIF()
+ENDIF(G2O_FOUND OR GTSAM_FOUND OR ZED_FOUND)
+
 ####### OSX BUNDLE CMAKE_INSTALL_PREFIX #######
 IF(APPLE AND BUILD_AS_BUNDLE)
   IF(Qt5_FOUND OR (QT4_FOUND AND QT_QTCORE_FOUND AND QT_QTGUI_FOUND))
@@ -242,24 +347,103 @@ ENDIF(APPLE AND BUILD_AS_BUNDLE)
 
 
 ####### SOURCES (Projects) #######
-SET(NONFREE 0)
-IF(OPENCV_NONFREE_FOUND OR OPENCV_XFEATURES2D_FOUND)
-   SET(NONFREE 1)
-ENDIF(OPENCV_NONFREE_FOUND OR OPENCV_XFEATURES2D_FOUND)
+
+# CONF_DEPENDENCIES contains only dependencies not required by the headers
+SET(CONF_DEPENDENCIES 
+	${ZLIB_LIBRARIES}
+)
+IF(NOT (OPENCV_NONFREE_FOUND OR OPENCV_XFEATURES2D_FOUND))
+   SET(NONFREE "//")
+ENDIF(NOT (OPENCV_NONFREE_FOUND OR OPENCV_XFEATURES2D_FOUND))
+IF(NOT G2O_FOUND)
+   SET(G2O "//")
+ELSE()
+   SET(CONF_DEPENDENCIES ${CONF_DEPENDENCIES} ${G2O_LIBRARIES})
+ENDIF()
+IF(NOT GTSAM_FOUND)
+   SET(GTSAM "//")
+ELSE()
+   SET(CONF_DEPENDENCIES ${CONF_DEPENDENCIES} ${GTSAM_LIBRARIES})
+ENDIF()
+IF(NOT WITH_TORO)
+   SET(TORO "//")
+ENDIF(NOT WITH_TORO)
+IF(NOT WITH_VERTIGO)
+   SET(VERTIGO "//")
+ENDIF(NOT WITH_VERTIGO)
+IF(NOT cvsba_FOUND)
+   SET(CVSBA "//")
+ELSE()
+   SET(CONF_DEPENDENCIES ${CONF_DEPENDENCIES} ${cvsba_LIBRARIES})
+ENDIF()
+IF(NOT Freenect_FOUND)
+   SET(FREENECT "//")
+ELSE()
+   SET(CONF_DEPENDENCIES ${CONF_DEPENDENCIES} ${Freenect_LIBRARIES})
+ENDIF()
+IF(NOT freenect2_FOUND)
+   SET(FREENECT2 "//")
+ELSE()
+   SET(CONF_DEPENDENCIES ${CONF_DEPENDENCIES} ${freenect2_LIBRARIES})
+ENDIF()
+IF(NOT OpenNI2_FOUND)
+   SET(OPENNI2 "//")
+ELSE()
+   SET(CONF_DEPENDENCIES ${CONF_DEPENDENCIES} ${OpenNI2_LIBRARIES})
+ENDIF()
+IF(NOT DC1394_FOUND)
+   SET(DC1394 "//")
+ELSE()
+   SET(CONF_DEPENDENCIES ${CONF_DEPENDENCIES} ${DC1394_LIBRARIES})
+ENDIF()
+IF(NOT FlyCapture2_FOUND)
+   SET(FLYCAPTURE2 "//")
+ELSE()
+   SET(CONF_DEPENDENCIES ${CONF_DEPENDENCIES} ${FlyCapture2_LIBRARIES})
+ENDIF()
+IF(NOT ZED_FOUND)
+   SET(ZED "//")
+ELSE()
+   SET(CONF_DEPENDENCIES ${CONF_DEPENDENCIES} ${ZED_LIBRARIES} ${CUDA_LIBRARIES}) 
+ENDIF()
+IF(NOT OCTOMAP_FOUND)
+   SET(OCTOMAP "//")
+ELSE()
+   SET(CONF_DEPENDENCIES ${CONF_DEPENDENCIES} ${OCTOMAP_LIBRARIES}) 
+ENDIF()
+IF(ADD_VTK_GUI_SUPPORT_QT_TO_CONF)
+   SET(CONF_VTK_QT true)
+   SET(CONF_DEPENDENCIES ${CONF_DEPENDENCIES} vtkGUISupportQt)
+ELSE()
+   SET(CONF_VTK_QT false)
+ENDIF()
+IF(NOT (OpenCV_FOUND AND OpenCV_VERSION_MAJOR EQUAL 3))
+   SET(OPENCV3 "//")
+ENDIF(NOT (OpenCV_FOUND AND OpenCV_VERSION_MAJOR EQUAL 3))
 CONFIGURE_FILE(Version.h.in ${PROJECT_SOURCE_DIR}/corelib/include/${PROJECT_PREFIX}/core/Version.h)
 
 ADD_SUBDIRECTORY( utilite )
 ADD_SUBDIRECTORY( corelib )
 
-IF(Qt5_FOUND OR (QT4_FOUND AND QT_QTCORE_FOUND AND QT_QTGUI_FOUND))
+IF(ANDROID)
+   IF(BUILD_APP)
+      ADD_SUBDIRECTORY( app )
+   ENDIF(BUILD_APP)
+ELSEIF(Qt5_FOUND OR (QT4_FOUND AND QT_QTCORE_FOUND AND QT_QTGUI_FOUND))
    ADD_SUBDIRECTORY( guilib )
-   ADD_SUBDIRECTORY( app )
+   IF(BUILD_APP)
+      ADD_SUBDIRECTORY( app )
+   ENDIF(BUILD_APP)
 ELSEIF(WITH_QT)
    MESSAGE(WARNING "Qt not found, the GUI lib and the stand-alone application will not be compiled...")
 ENDIF()
 
-ADD_SUBDIRECTORY( tools )
-ADD_SUBDIRECTORY( examples )
+IF(BUILD_TOOLS)
+   ADD_SUBDIRECTORY( tools )
+ENDIF(BUILD_TOOLS)
+IF(BUILD_EXAMPLES)
+   ADD_SUBDIRECTORY( examples )
+ENDIF(BUILD_EXAMPLES)
 
 #######################
 # Uninstall target, for "make uninstall"
@@ -283,8 +467,17 @@ file(RELATIVE_PATH REL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/${INSTALL_CMAKE_DIR}" "$
 set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/corelib/include" 
 					  "${PROJECT_SOURCE_DIR}/guilib/include" 
 					  "${PROJECT_SOURCE_DIR}/utilite/include")
-set(CONF_LIB_DIR "${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}")
-set(CONF_WITH_GUI ${WITH_QT})
+set(CONF_LIB_DIR "${CMAKE_ARCHIVE_OUTPUT_DIRECTORY} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
+IF(QT4_FOUND OR Qt5_FOUND)
+   set(CONF_WITH_GUI ON)
+   IF(QT4_FOUND)
+      set(CONF_QT_VERSION 4)
+   ELSE()
+      set(CONF_QT_VERSION 5)
+   ENDIF()
+ELSE()
+   set(CONF_WITH_GUI OFF)
+ENDIF()
 configure_file(RTABMapConfig.cmake.in
   "${PROJECT_BINARY_DIR}/RTABMapConfig.cmake" @ONLY)
   
@@ -390,34 +583,40 @@ INCLUDE(CPack)
 
 MESSAGE(STATUS "--------------------------------------------")
 MESSAGE(STATUS "Info :")
+MESSAGE(STATUS "  Version : ${RTABMAP_VERSION}")
 MESSAGE(STATUS "  CMAKE_INSTALL_PREFIX = ${CMAKE_INSTALL_PREFIX}")
-MESSAGE(STATUS "  CMAKE_BUILD_TYPE = ${CMAKE_BUILD_TYPE}")
+MESSAGE(STATUS "  CMAKE_BUILD_TYPE =     ${CMAKE_BUILD_TYPE}")
+MESSAGE(STATUS "  CMAKE_INSTALL_LIBDIR = ${CMAKE_INSTALL_LIBDIR}")
+MESSAGE(STATUS "  BUILD_APP =            ${BUILD_APP}")
+MESSAGE(STATUS "  BUILD_TOOLS =          ${BUILD_TOOLS}")
+MESSAGE(STATUS "  BUILD_EXAMPLES =       ${BUILD_EXAMPLES}")
 IF(NOT WIN32)
 	# see comment above for the BUILD_SHARED_LIBS option on Windows
-	MESSAGE(STATUS "  BUILD_SHARED_LIBS = ${BUILD_SHARED_LIBS}")
+	MESSAGE(STATUS "  BUILD_SHARED_LIBS =    ${BUILD_SHARED_LIBS}")
 ENDIF(NOT WIN32)
 IF(APPLE)
-MESSAGE(STATUS "  BUILD_AS_BUNDLE = ${BUILD_AS_BUNDLE}")
+MESSAGE(STATUS "  BUILD_AS_BUNDLE =      ${BUILD_AS_BUNDLE}")
 ENDIF(APPLE)
+MESSAGE(STATUS "  CMAKE_CXX_FLAGS = ${CMAKE_CXX_FLAGS}")
 
 IF(OpenCV_FOUND)
   IF(OpenCV_VERSION_MAJOR EQUAL 2)
     IF(OPENCV_NONFREE_FOUND)
-      MESSAGE(STATUS "  With OpenCV 2 nonfree module (SIFT/SURF) = YES")
+      MESSAGE(STATUS "  With OpenCV 2 nonfree module (SIFT/SURF) = YES (License: Non commercial)")
     ELSE()
-      MESSAGE(STATUS "  With OpenCV 2 nonfree module (SIFT/SURF) = NO (not found)")
+      MESSAGE(STATUS "  With OpenCV 2 nonfree module (SIFT/SURF) = NO (not found, License: BSD)")
     ENDIF()
   ELSE()
     IF(OPENCV_XFEATURES2D_FOUND)
-      MESSAGE(STATUS "  With OpenCV 3 xfeatures2d module (SIFT/SURF/BRIEF/FREAK) = YES")
+      MESSAGE(STATUS "  With OpenCV 3 xfeatures2d module (SIFT/SURF/BRIEF/FREAK) = YES (License: Non commercial)")
     ELSE()
-      MESSAGE(STATUS "  With OpenCV 3 xfeatures2d module (SIFT/SURF/BRIEF/FREAK) = NO (not found)")
+      MESSAGE(STATUS "  With OpenCV 3 xfeatures2d module (SIFT/SURF/BRIEF/FREAK) = NO (not found, License: BSD)")
     ENDIF()
   ENDIF()
 ENDIF(OpenCV_FOUND)
 
 IF(Freenect_FOUND)
-MESSAGE(STATUS "  With Freenect             = YES")
+MESSAGE(STATUS "  With Freenect             = YES (License: Apache v2 and/or GPLv2)")
 ELSEIF(NOT WITH_FREENECT)
 MESSAGE(STATUS "  With Freenect             = NO (WITH_FREENECT=OFF)")
 ELSE()
@@ -425,7 +624,7 @@ MESSAGE(STATUS "  With Freenect             = NO (libfreenect not found)")
 ENDIF()
 
 IF(OpenNI2_FOUND)
-MESSAGE(STATUS "  With OpenNI2              = YES")
+MESSAGE(STATUS "  With OpenNI2              = YES (License: Apache v2)")
 ELSEIF(NOT WITH_OPENNI2)
 MESSAGE(STATUS "  With OpenNI2              = NO (WITH_OPENNI2=OFF)")
 ELSE()
@@ -433,7 +632,7 @@ MESSAGE(STATUS "  With OpenNI2              = NO (OpenNI2 not found)")
 ENDIF()
 
 IF(freenect2_FOUND)
-MESSAGE(STATUS "  With Freenect2            = YES")
+MESSAGE(STATUS "  With Freenect2            = YES (License: Apache v2 and/or GPLv2)")
 ELSEIF(NOT WITH_FREENECT2)
 MESSAGE(STATUS "  With Freenect2            = NO (WITH_FREENECT2=OFF)")
 ELSE()
@@ -441,7 +640,7 @@ MESSAGE(STATUS "  With Freenect2            = NO (libfreenect2 not found)")
 ENDIF()
 
 IF(DC1394_FOUND)
-MESSAGE(STATUS "  With dc1394               = YES")
+MESSAGE(STATUS "  With dc1394               = YES (License: LGPL)")
 ELSEIF(NOT WITH_DC1394)
 MESSAGE(STATUS "  With dc1394               = NO (WITH_DC1394=OFF)")
 ELSE()
@@ -456,8 +655,14 @@ ELSE()
 MESSAGE(STATUS "  With FlyCapture2/Triclops = NO (Point Grey SDK not found)")
 ENDIF()
 
+IF(WITH_TORO)
+MESSAGE(STATUS "  With TORO                 = YES (License: Creative Commons [Attribution-NonCommercial-ShareAlike])")
+ELSE()
+MESSAGE(STATUS "  With TORO                 = NO (WITH_TORO=OFF)")
+ENDIF()
+
 IF(G2O_FOUND)
-MESSAGE(STATUS "  With g2o                  = YES")
+MESSAGE(STATUS "  With g2o                  = YES (License: BSD)")
 ELSEIF(NOT WITH_G2O)
 MESSAGE(STATUS "  With g2o                  = NO (WITH_G2O=OFF)")
 ELSE()
@@ -465,29 +670,62 @@ MESSAGE(STATUS "  With g2o                  = NO (g2o not found)")
 ENDIF()
 
 IF(GTSAM_FOUND)
-MESSAGE(STATUS "  With GTSAM                = YES")
+MESSAGE(STATUS "  With GTSAM                = YES (License: BSD)")
 ELSEIF(NOT WITH_GTSAM)
 MESSAGE(STATUS "  With GTSAM                = NO (WITH_GTSAM=OFF)")
 ELSE()
 MESSAGE(STATUS "  With GTSAM                = NO (GTSAM not found)")
 ENDIF()
 
+IF(WITH_VERTIGO)
+MESSAGE(STATUS "  With VERTIGO              = YES (License: GPLv3)")
+ELSE()
+MESSAGE(STATUS "  With VERTIGO              = NO (WITH_VERTIGO=OFF)")
+ENDIF()
+
 IF(cvsba_FOUND)
-MESSAGE(STATUS "  With cvsba                = YES")
+MESSAGE(STATUS "  With cvsba                = YES (License: GPLv2)")
 ELSEIF(NOT WITH_CVSBA)
 MESSAGE(STATUS "  With cvsba                = NO (WITH_CVSBA=OFF)")
 ELSE()
 MESSAGE(STATUS "  With cvsba                = NO (cvsba not found)")
 ENDIF()
 
+IF(ZED_FOUND)
+IF(CUDA_FOUND)
+MESSAGE(STATUS "  With ZED                  = YES (With CUDA)")
+ELSE()
+MESSAGE(STATUS "  With ZED                  = YES (Without CUDA)")
+ENDIF()
+ELSEIF(NOT WITH_ZED)
+MESSAGE(STATUS "  With ZED                  = NO (WITH_ZED=OFF)")
+ELSE()
+MESSAGE(STATUS "  With ZED                  = NO (ZED sdk not found)")
+ENDIF()
+
+IF(OCTOMAP_FOUND)
+MESSAGE(STATUS "  With OCTOMAP              = YES (License: BSD)")
+ELSEIF(NOT WITH_OCTOMAP)
+MESSAGE(STATUS "  With OCTOMAP              = NO (WITH_OCTOMAP=OFF)")
+ELSE()
+MESSAGE(STATUS "  With OCTOMAP              = NO (octomap not found)")
+ENDIF()
+
 IF(QT4_FOUND)
-MESSAGE(STATUS "  With Qt                   = YES (version 4)")
+MESSAGE(STATUS "  With Qt4                  = YES (License: Open Source or Commercial)")
 ELSEIF(Qt5_FOUND)
-MESSAGE(STATUS "  With Qt                   = YES (version 5)")
+MESSAGE(STATUS "  With Qt5                  = YES (License: Open Source or Commercial)")
 ELSEIF(NOT WITH_QT)
 MESSAGE(STATUS "  With Qt                   = NO (WITH_QT=OFF)")
 ELSE()
-MESSAGE(STATUS "  With Qt                   = NO (Qt not found, to use Qt5 you should set -DRTABMAP_QT_VERSION=5)")
+MESSAGE(STATUS "  With Qt                   = NO (Qt not found)")
 ENDIF()
 
 MESSAGE(STATUS "--------------------------------------------")
+
+IF(NOT GTSAM_FOUND AND NOT G2O_FOUND AND NOT WITH_TORO)
+MESSAGE(SEND_ERROR "No graph optimizer found! You should have at least one of these options:
+       g2o (https://github.com/RainerKuemmerle/g2o)
+       GTSAM (https://collab.cc.gatech.edu/borg/gtsam)
+       set -DWITH_TORO=ON")
+ENDIF(NOT GTSAM_FOUND AND NOT G2O_FOUND AND NOT WITH_TORO)

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2015, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

Matlab/ParticleFilter/pf_filter.m

@@ -18,7 +18,7 @@ for i = 1:length(x);
     if sum(weights(:)) > 0
          weights = weights ./sum(weights(:));
     end
-   
+
     filtered(i) = weights'*particles;
     particles = pf_resample(particles, weights);
 end

Matlab/ParticleFilter/pf_filter.m~

@@ -1,18 +0,0 @@
-
-function filtered = pf_filter(x, nParticles, noise, lambda)
-
-particles = zeros(nParticles,1) ;
-weights = zeros(nParticles,1);
-filtered=zeros(1,length(x));
-for i = 1:length(x);
-    for j = 1:nParticles 
-        rn = sqrt(-2.0*log(rand))*cos(2*pi*rand); % randn c++
-        bruit= noise*rn;
-        particles(j) = particles(j) + bruit ;
-        dist = abs(particles(j) - x(i));
-        weights(j) = exp(-lambda*dist);
-    end
-    weights = weights ./(sum(weights(:)));
-    filtered(i) = weights'*particles;
-    particles = Rresample2(particles,weights);
-end

Matlab/ParticleFilter/test_pf_filter.m

@@ -0,0 +1,47 @@
+
+
+clc
+%close all
+
+particles = 300;
+noiseXYZ = 0.02;
+lambdaXYZ = 1;
+noiseRPY = 0.005;
+lambdaRPY = 250;
+noise = [noiseXYZ noiseXYZ noiseXYZ noiseRPY noiseRPY noiseRPY];
+lambda = [lambdaXYZ lambdaXYZ lambdaXYZ lambdaRPY lambdaRPY lambdaRPY];
+axeNames = ['x' 'y' 'z' 'R' 'P' 'Y'];
+
+% P = [13 x t] (id, incremental odom, incremental ground truth)
+T = P(2:7,:);
+G = P(8:end,:);
+
+T(4:end,:) = T(4:end,:)*pi/180;
+G(4:end,:) = G(4:end,:)*pi/180;
+
+
+x_filtered = zeros(6, size(T, 2));
+for i=1:6
+    x=T(i,:);
+    x=x';
+    x_filtered(i,:) = pf_filter([x(2:end); 0], particles, noise(i), lambda(i));
+   
+end
+
+figure
+for i=1:6
+    subplot(2,3,i)
+    x=T(i,:);
+    x_gt = G(i,:);
+    plot(1:length(x),cumsum(x),'b', 1:length(x),cumsum(x_filtered(i,:)),'r', 1:length(x),cumsum(x_gt),'g');
+    legend(axeNames(i), [axeNames(i) ' filtered'], [axeNames(i) ' gt'])
+end
+
+figure
+for i=1:6
+    subplot(2,3,i)
+    x=T(i,:);
+    x_gt = G(i,:);
+    plot(1:length(x),x,'b', 1:length(x),x_filtered(i,:),'r', 1:length(x),x_gt,'g');
+    legend(axeNames(i), [axeNames(i) ' filtered'], [axeNames(i) ' gt'])
+end

README.md

@@ -1,4 +1,4 @@
-rtabmap
+rtabmap [![Build Status](https://travis-ci.org/introlab/rtabmap.svg?branch=master)](https://travis-ci.org/introlab/rtabmap)
 =======
 
 RTAB-Map library and standalone application.

RTABMapConfig.cmake.in

@@ -11,41 +11,41 @@ get_filename_component(RTABMap_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
 set(RTABMap_INCLUDE_DIRS "@CONF_INCLUDE_DIRS@")
 
 #core lib
-find_library(RTABMap_CORE_RELEASE NAMES rtabmap_core NO_DEFAULT_PATH HINTS "@CONF_LIB_DIR@")
-find_library(RTABMap_CORE_DEBUG NAMES rtabmap_cored NO_DEFAULT_PATH HINTS "@CONF_LIB_DIR@")
+find_library(RTABMap_CORE_RELEASE NAMES rtabmap_core NO_DEFAULT_PATH HINTS @CONF_LIB_DIR@)
+find_library(RTABMap_CORE_DEBUG NAMES rtabmap_cored NO_DEFAULT_PATH HINTS @CONF_LIB_DIR@)
 
 IF(RTABMap_CORE_DEBUG AND RTABMap_CORE_RELEASE)
    SET(RTABMap_CORE
       debug ${RTABMap_CORE_DEBUG}
       optimized ${RTABMap_CORE_RELEASE}
    )
-ELSEIF(RTABMap_CORE_RELEASE)
-   SET(RTABMap_CORE ${RTABMap_CORE_RELEASE})
 ELSEIF(RTABMap_CORE_DEBUG)
    SET(RTABMap_CORE ${RTABMap_CORE_DEBUG})
+ELSE()
+   SET(RTABMap_CORE ${RTABMap_CORE_RELEASE})
 ENDIF()
 
 #utilite lib
-find_library(RTABMap_UTILITE_RELEASE NAMES rtabmap_utilite NO_DEFAULT_PATH HINTS "@CONF_LIB_DIR@")
-find_library(RTABMap_UTILITE_DEBUG NAMES rtabmap_utilited NO_DEFAULT_PATH HINTS "@CONF_LIB_DIR@")
+find_library(RTABMap_UTILITE_RELEASE NAMES rtabmap_utilite NO_DEFAULT_PATH HINTS @CONF_LIB_DIR@)
+find_library(RTABMap_UTILITE_DEBUG NAMES rtabmap_utilited NO_DEFAULT_PATH HINTS @CONF_LIB_DIR@)
 
 IF(RTABMap_UTILITE_DEBUG AND RTABMap_UTILITE_RELEASE)
    SET(RTABMap_UTILITE
       debug ${RTABMap_UTILITE_DEBUG}
       optimized ${RTABMap_UTILITE_RELEASE}
    )
-ELSEIF(RTABMap_UTILITE_RELEASE)
-   SET(RTABMap_UTILITE ${RTABMap_UTILITE_RELEASE})
 ELSEIF(RTABMap_UTILITE_DEBUG)
    SET(RTABMap_UTILITE ${RTABMap_UTILITE_DEBUG})
+ELSE()
+   SET(RTABMap_UTILITE ${RTABMap_UTILITE_RELEASE})
 ENDIF()
 
 set(RTABMap_LIBRARIES ${RTABMap_CORE} ${RTABMap_UTILITE})
 
 #gui lib (OFF if RTAB-Map is not built with Qt)
 if(@CONF_WITH_GUI@)
-   find_library(RTABMap_GUI_RELEASE NAMES rtabmap_gui NO_DEFAULT_PATH HINTS "@CONF_LIB_DIR@")
-   find_library(RTABMap_GUI_DEBUG NAMES rtabmap_guid NO_DEFAULT_PATH HINTS "@CONF_LIB_DIR@")
+   find_library(RTABMap_GUI_RELEASE NAMES rtabmap_gui NO_DEFAULT_PATH HINTS @CONF_LIB_DIR@)
+   find_library(RTABMap_GUI_DEBUG NAMES rtabmap_guid NO_DEFAULT_PATH HINTS @CONF_LIB_DIR@)
    
    IF(RTABMap_GUI_DEBUG AND RTABMap_GUI_RELEASE)
       SET(RTABMap_GUI
@@ -61,13 +61,16 @@ if(@CONF_WITH_GUI@)
    set(RTABMap_LIBRARIES ${RTABMap_LIBRARIES} ${RTABMap_GUI})
 endif(@CONF_WITH_GUI@)
 
+# Dependencies
+if(@CONF_VTK_QT@)
+   find_package(VTK COMPONENTS vtkGUISupportQt NO_MODULE) # to define vtkGUISupportQt target
+endif(@CONF_VTK_QT@)
+set(RTABMap_LIBRARIES ${RTABMap_LIBRARIES} @CONF_DEPENDENCIES@)
+
 #backward compatibilities
-if(RTABMap_CORE)
-   set(RTABMAP_CORE ${RTABMap_CORE})
-endif(RTABMap_CORE)
-if(RTABMap_UTILITE)
-   set(RTABMAP_UTILITE ${RTABMap_UTILITE})
-endif(RTABMap_UTILITE)
+set(RTABMAP_CORE ${RTABMap_CORE})
+set(RTABMAP_UTILITE ${RTABMap_UTILITE})
 if(RTABMap_GUI)
    set(RTABMAP_GUI ${RTABMap_GUI})
-endif(RTABMap_GUI)
+   set(RTABMAP_QT_VERSION @CONF_QT_VERSION@)
+endif(RTABMap_GUI)

Version.h.in

@@ -37,7 +37,20 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #define RTABMAP_VERSION_COMPARE(major, minor, patch)  (major>=@PROJECT_VERSION_MAJOR@ || (major==@PROJECT_VERSION_MAJOR@ && minor>=@PROJECT_VERSION_MINOR@) || (major==@PROJECT_VERSION_MAJOR@ && minor==@PROJECT_VERSION_MINOR@ && patch >=@PROJECT_VERSION_PATCH@))
 
-#define RTABMAP_NONFREE @NONFREE@
+@NONFREE@#define RTABMAP_NONFREE
+@TORO@#define RTABMAP_TORO
+@G2O@#define RTABMAP_G2O
+@GTSAM@#define RTABMAP_GTSAM
+@VERTIGO@#define RTABMAP_VERTIGO
+@OPENCV3@#define RTABMAP_OPENCV3
+@OPENNI2@#define RTABMAP_OPENNI2
+@FREENECT@#define RTABMAP_FREENECT
+@FREENECT2@#define RTABMAP_FREENECT2
+@CVSBA@#define RTABMAP_CVSBA
+@DC1394@#define RTABMAP_DC1394
+@FLYCAPTURE2@#define RTABMAP_FLYCAPTURE2
+@ZED@#define RTABMAP_ZED
+@OCTOMAP@#define RTABMAP_OCTOMAP
 
 #endif /* VERSION_H_ */
 

app/CMakeLists.txt

@@ -1 +1,6 @@
-ADD_SUBDIRECTORY( src )
+
+IF(ANDROID)
+   ADD_SUBDIRECTORY( android )
+ELSE()
+   ADD_SUBDIRECTORY( src )
+ENDIF()

app/android/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6

app/android/AndroidManifest.xml.in

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- BEGIN_INCLUDE(manifest) -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+        package="com.introlab.rtabmap"
+        android:versionCode="9"
+        android:versionName="@RTABMAP_VERSION@">
+
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.READ_FRAME_BUFFER" />
+    <uses-permission android:name="android.permission.ACCESS_SURFACE_FLINGER" />
+    <uses-feature android:glEsVersion="0x00020000" />
+    <uses-library android:name="com.projecttango.libtango_device2" android:required="true" />
+
+    <!-- This is the platform API where NativeActivity was introduced. -->
+    <uses-sdk android:minSdkVersion="17" />
+
+    <!-- This .apk has no Java code itself, so set hasCode to false. -->
+    <application 
+        android:label="@string/app_name" 
+        android:icon="@drawable/ic_launcher">
+
+        <!-- Our activity is the built-in NativeActivity framework class.
+             This will take care of integrating with our NDK code. -->
+        <activity android:name="RTABMapActivity"
+                android:label="@string/app_name"
+                android:launchMode="singleTask"
+                android:screenOrientation="nosensor">
+            <!-- Tell NativeActivity the name of our .so -->
+            <meta-data android:name="android.app.lib_name"
+                    android:value="NativeRTABMap" />
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
+<!-- END_INCLUDE(manifest) -->

app/android/CMakeLists.txt

@@ -0,0 +1,87 @@
+
+add_subdirectory(jni)
+
+
+######
+# Packaging
+######
+
+# find android
+find_host_program(ANDROID_EXECUTABLE
+  NAMES android
+  DOC   "The android command-line tool")
+if(NOT ANDROID_EXECUTABLE)
+  message(FATAL_ERROR "Can not find android command line tool: android")
+endif()
+
+configure_file(
+  "${CMAKE_CURRENT_SOURCE_DIR}/AndroidManifest.xml.in"
+  "${CMAKE_CURRENT_SOURCE_DIR}/AndroidManifest.xml")
+  
+configure_file(
+  "${CMAKE_CURRENT_SOURCE_DIR}/AndroidManifest.xml"
+  "${CMAKE_CURRENT_BINARY_DIR}/AndroidManifest.xml"
+  COPYONLY)
+  
+configure_file(
+  "${CMAKE_CURRENT_SOURCE_DIR}/info.txt.in"
+  "${CMAKE_CURRENT_SOURCE_DIR}/res/raw/info.txt")
+  
+
+configure_file(
+  "${CMAKE_CURRENT_SOURCE_DIR}/ant.properties.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/ant.properties"
+  @ONLY)
+
+add_custom_target(NativeRTABMap-ant-configure ALL
+  COMMAND "${ANDROID_EXECUTABLE}"
+          update project
+          --name RTABMap
+          --path "${CMAKE_CURRENT_SOURCE_DIR}"
+          --target "android-${ANDROID_NATIVE_API_LEVEL}"
+  COMMAND "${CMAKE_COMMAND}" -E copy_if_different
+          "${CMAKE_CURRENT_SOURCE_DIR}/build.xml"
+          "${CMAKE_CURRENT_BINARY_DIR}/build.xml"
+  COMMAND "${CMAKE_COMMAND}" -E copy_if_different
+          "${CMAKE_CURRENT_SOURCE_DIR}/local.properties"
+          "${CMAKE_CURRENT_BINARY_DIR}/local.properties"
+  COMMAND "${CMAKE_COMMAND}" -E copy_if_different
+          "${CMAKE_CURRENT_SOURCE_DIR}/project.properties"
+          "${CMAKE_CURRENT_BINARY_DIR}/project.properties"
+  COMMAND "${CMAKE_COMMAND}" -E copy_if_different
+          "${CMAKE_CURRENT_SOURCE_DIR}/proguard-project.txt"
+          "${CMAKE_CURRENT_BINARY_DIR}/proguard-project.txt"
+  COMMAND "${CMAKE_COMMAND}" -E remove
+          "${CMAKE_CURRENT_SOURCE_DIR}/build.xml"
+          "${CMAKE_CURRENT_SOURCE_DIR}/local.properties"
+          "${CMAKE_CURRENT_SOURCE_DIR}/project.properties"
+          "${CMAKE_CURRENT_SOURCE_DIR}/proguard-project.txt"
+  WORKING_DIRECTORY
+          "${CMAKE_CURRENT_BINARY_DIR}")
+
+add_dependencies(NativeRTABMap-ant-configure NativeRTABMap)
+
+#find ant
+find_host_program(ANT_EXECUTABLE
+  NAMES ant
+  DOC   "The ant build tool")
+if(NOT ANT_EXECUTABLE)
+  message(FATAL_ERROR "Can not find ant build tool: ant")
+endif()
+
+add_custom_target(NativeRTABMap-apk-release ALL
+  COMMAND ${ANT_EXECUTABLE}
+          -file "${CMAKE_CURRENT_BINARY_DIR}/build.xml"
+          release)
+add_dependencies(NativeRTABMap-apk-release
+  NativeRTABMap-ant-configure
+  NativeRTABMap)
+
+add_custom_target(NativeRTABMap-apk-debug ALL
+  COMMAND ${ANT_EXECUTABLE}
+          -file "${CMAKE_CURRENT_BINARY_DIR}/build.xml"
+          debug)
+add_dependencies(NativeRTABMap-apk-debug
+#  NativeRTABMap-apk-release
+  NativeRTABMap-ant-configure
+  NativeRTABMap)

app/android/ant.properties.in

@@ -0,0 +1,12 @@
+builddir=@CMAKE_CURRENT_BINARY_DIR@
+srcdir=@CMAKE_CURRENT_SOURCE_DIR@
+
+source.dir=${srcdir}/src
+gen.dir=${builddir}/gen
+out.dir=${builddir}/bin
+asset.dir=${builddir}/assets
+resource.absolute.dir=${srcdir}/res
+
+jar.libs.dir=${builddir}/libs
+external.libs.dir=${builddir}/libs
+native.libs.dir=${builddir}/libs

app/android/info.txt.in

@@ -0,0 +1,8 @@
+<h3>Real-Time Appearance-Based Mapping</h3>
+Version @RTABMAP_VERSION@<br>
+Author: Mathieu Labb&eacute;<br>
+Copyright 2016<br>
+IntRoLab - Universit&eacute; de Sherbrooke<br>
+<b>http://introlab.github.io/rtabmap</b><br><br>
+
+

app/android/jni/CMakeLists.txt

@@ -0,0 +1,60 @@
+
+find_package(Tango REQUIRED)
+
+SET(INCLUDE_DIRS
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/tango-gl/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/third-party/include
+	${PROJECT_SOURCE_DIR}/corelib/include
+	${PROJECT_SOURCE_DIR}/utilite/include
+    ${OpenCV_INCLUDE_DIRS}
+    ${PCL_INCLUDE_DIRS}
+    ${Tango_INCLUDE_DIRS}
+    "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include"
+)
+
+SET(LIBRARIES
+	${OpenCV_LIBRARIES} 
+	${PCL_LIBRARIES}
+	${Tango_LIBRARIES}
+)
+
+add_definitions(${PCL_DEFINITIONS})
+
+INCLUDE_DIRECTORIES(${INCLUDE_DIRS})
+
+set(sources
+  jni_interface.cpp
+  CameraTango.cpp
+  RTABMapApp.cpp
+  scene.cpp
+  point_cloud_drawable.cpp
+  graph_drawable.cpp
+  tango-gl/axis.cpp 
+  tango-gl/camera.cpp 
+  tango-gl/conversions.cpp 
+  tango-gl/drawable_object.cpp 
+  tango-gl/frustum.cpp 
+  tango-gl/gesture_camera.cpp 
+  tango-gl/grid.cpp 
+  tango-gl/line.cpp 
+  tango-gl/shaders.cpp 
+  tango-gl/trace.cpp 
+  tango-gl/transform.cpp 
+  tango-gl/util.cpp
+)
+
+add_library(NativeRTABMap SHARED ${sources})        
+target_link_libraries(NativeRTABMap ${LIBRARIES}
+  android
+  log
+  GLESv2
+  rtabmap_core
+  rtabmap_utilite
+)
+
+# see ant.properties.in
+set_target_properties(NativeRTABMap PROPERTIES
+         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/../libs/${ANDROID_NDK_ABI_NAME}"
+         LIBRARY_OUTPUT_DIRECTORY_DEBUG "${CMAKE_CURRENT_BINARY_DIR}/../libs/${ANDROID_NDK_ABI_NAME}"
+         LIBRARY_OUTPUT_DIRECTORY_RELEASE "${CMAKE_CURRENT_BINARY_DIR}/../libs/${ANDROID_NDK_ABI_NAME}")

app/android/jni/CameraTango.cpp

@@ -0,0 +1,654 @@
+/*
+Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "CameraTango.h"
+#include "util.h"
+#include "rtabmap/utilite/ULogger.h"
+#include "rtabmap/core/util3d_transforms.h"
+#include "rtabmap/core/util2d.h"
+#include "rtabmap/core/OdometryEvent.h"
+#include <tango_client_api.h>
+
+namespace rtabmap {
+
+#define nullptr 0
+const int kVersionStringLength = 128;
+const int holeSize = 10;
+const float maxDepthError = 0.10;
+
+// Callbacks
+void onPointCloudAvailableRouter(void* context, const TangoXYZij* xyz_ij)
+{
+	CameraTango* app = static_cast<CameraTango*>(context);
+	app->cloudReceived(cv::Mat(1, xyz_ij->xyz_count, CV_32FC3, xyz_ij->xyz[0]), xyz_ij->timestamp);
+}
+
+void onFrameAvailableRouter(void* context, TangoCameraId id, const TangoImageBuffer* color)
+{
+	CameraTango* app = static_cast<CameraTango*>(context);
+	cv::Mat tangoImage;
+	if(color->format == TANGO_HAL_PIXEL_FORMAT_RGBA_8888)
+	{
+		tangoImage = cv::Mat(color->height, color->width, CV_8UC4, color->data);
+	}
+	else if(color->format == TANGO_HAL_PIXEL_FORMAT_YV12)
+	{
+		tangoImage = cv::Mat(color->height+color->height/2, color->width, CV_8UC1, color->data);
+	}
+	else if(color->format == TANGO_HAL_PIXEL_FORMAT_YCrCb_420_SP)
+	{
+		tangoImage = cv::Mat(color->height+color->height/2, color->width, CV_8UC1, color->data);
+	}
+	else
+	{
+		LOGE("Not supported color format : %d.", color->format);
+	}
+
+	if(!tangoImage.empty())
+	{
+		app->rgbReceived(tangoImage, (unsigned int)color->format, color->timestamp);
+	}
+}
+
+void onPoseAvailableRouter(void* context, const TangoPoseData* pose)
+{
+	CameraTango* app = static_cast<CameraTango*>(context);
+	app->poseReceived(app->tangoPoseToTransform(pose, true));
+}
+
+void onTangoEventAvailableRouter(void* context, const TangoEvent* event)
+{
+	CameraTango* app = static_cast<CameraTango*>(context);
+	app->tangoEventReceived(event->type, event->event_key, event->event_value);
+}
+
+// In OpenGL, axes are x->right, y->up and z->outScreen
+// Image is x->right, y->down and z->inScreen
+static rtabmap::Transform opticalRotation(
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, -1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, -1.0f, 0.0f);
+
+//////////////////////////////
+// CameraTango
+//////////////////////////////
+CameraTango::CameraTango(int decimation, bool autoExposure) :
+		Camera(0, opticalRotation),
+		tango_config_(0),
+		firstFrame_(true),
+		decimation_(decimation),
+		autoExposure_(autoExposure),
+		cloudStamp_(0),
+		tangoColorType_(0),
+		tangoColorStamp_(0)
+{
+	UASSERT(decimation >= 1);
+}
+
+CameraTango::~CameraTango() {
+	// Disconnect Tango service
+	close();
+}
+
+bool CameraTango::init(const std::string & calibrationFolder, const std::string & cameraName)
+{
+	close();
+
+	// Connect to Tango
+	LOGI("NativeRTABMap: Setup tango config");
+	tango_config_ = TangoService_getConfig(TANGO_CONFIG_DEFAULT);
+	if (tango_config_ == nullptr)
+	{
+		LOGE("NativeRTABMap: Failed to get default config form");
+		return false;
+	}
+
+	// Set auto-recovery for motion tracking as requested by the user.
+	bool is_atuo_recovery = true;
+	int ret = TangoConfig_setBool(tango_config_, "config_enable_auto_recovery", is_atuo_recovery);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: config_enable_auto_recovery() failed with error code: %d", ret);
+		return false;
+	}
+
+	// Enable color.
+	ret = TangoConfig_setBool(tango_config_, "config_enable_color_camera", true);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: config_enable_color_camera() failed with error code: %d", ret);
+		return false;
+	}
+
+	// disable auto exposure (disabled, seems broken on latest Tango releases)
+	ret = TangoConfig_setBool(tango_config_, "config_color_mode_auto", autoExposure_);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: config_color_mode_auto() failed with error code: %d", ret);
+		//return false;
+	}
+	else
+	{
+		if(!autoExposure_)
+		{
+			ret = TangoConfig_setInt32(tango_config_, "config_color_iso", 800);
+			if (ret != TANGO_SUCCESS)
+			{
+				LOGE("NativeRTABMap: config_color_iso() failed with error code: %d", ret);
+				return false;
+			}
+		}
+		bool verifyAutoExposureState;
+		int32_t verifyIso, verifyExp;
+		TangoConfig_getBool( tango_config_, "config_color_mode_auto", &verifyAutoExposureState );
+		TangoConfig_getInt32( tango_config_, "config_color_iso", &verifyIso );
+		TangoConfig_getInt32( tango_config_, "config_color_exp", &verifyExp );
+		LOGI( "NativeRTABMap: config_color autoExposure=%s %d %d", verifyAutoExposureState?"On" : "Off", verifyIso, verifyExp );
+	}
+
+	// Enable depth.
+	ret = TangoConfig_setBool(tango_config_, "config_enable_depth", true);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: config_enable_depth() failed with error code: %d", ret);
+		return false;
+	}
+
+	// Note that it's super important for AR applications that we enable low
+	// latency imu integration so that we have pose information available as
+	// quickly as possible. Without setting this flag, you'll often receive
+	// invalid poses when calling GetPoseAtTime for an image.
+	ret = TangoConfig_setBool(tango_config_, "config_enable_low_latency_imu_integration", true);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: Failed to enable low latency imu integration.");
+		return false;
+	}
+
+	// Get TangoCore version string from service.
+	char tango_core_version[kVersionStringLength];
+	ret = TangoConfig_getString(tango_config_, "tango_service_library_version", tango_core_version, kVersionStringLength);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: get tango core version failed with error code: %d", ret);
+		return false;
+	}
+	LOGI("NativeRTABMap: Tango version : %s", tango_core_version);
+
+
+	// Callbacks
+	LOGI("NativeRTABMap: Setup callbacks");
+	// Attach the OnXYZijAvailable callback.
+	// The callback will be called after the service is connected.
+	ret = TangoService_connectOnXYZijAvailable(onPointCloudAvailableRouter);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: Failed to connect to point cloud callback with error code: %d", ret);
+		return false;
+	}
+
+	ret = TangoService_connectOnFrameAvailable(TANGO_CAMERA_COLOR, this, onFrameAvailableRouter);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: Failed to connect to color callback with error code: %d", ret);
+		return false;
+	}
+
+	// Attach the onPoseAvailable callback.
+	// The callback will be called after the service is connected.
+	TangoCoordinateFramePair pair;
+	pair.base = TANGO_COORDINATE_FRAME_START_OF_SERVICE;
+	pair.target = TANGO_COORDINATE_FRAME_DEVICE;
+	ret = TangoService_connectOnPoseAvailable(1, &pair, onPoseAvailableRouter);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: Failed to connect to pose callback with error code: %d", ret);
+		return false;
+	}
+
+	// Attach the onEventAvailable callback.
+	// The callback will be called after the service is connected.
+	ret = TangoService_connectOnTangoEvent(onTangoEventAvailableRouter);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("PointCloudApp: Failed to connect to event callback with error code: %d", ret);
+		return false;
+	}
+
+	// Now connect service so the callbacks above will be called
+	LOGI("NativeRTABMap: Connect to tango service");
+	ret = TangoService_connect(this, tango_config_);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: Failed to connect to the Tango service with error code: %d", ret);
+		return false;
+	}
+
+	// update extrinsics
+	LOGI("NativeRTABMap: Update extrinsics");
+	TangoPoseData pose_data;
+	TangoCoordinateFramePair frame_pair;
+
+	// TangoService_getPoseAtTime function is used for query device extrinsics
+	// as well. We use timestamp 0.0 and the target frame pair to get the
+	// extrinsics from the sensors.
+	//
+	// Get device with respect to imu transformation matrix.
+	frame_pair.base = TANGO_COORDINATE_FRAME_IMU;
+	frame_pair.target = TANGO_COORDINATE_FRAME_DEVICE;
+	ret = TangoService_getPoseAtTime(0.0, frame_pair, &pose_data);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: Failed to get transform between the IMU frame and device frames");
+		return false;
+	}
+	imuTDevice_ = rtabmap::Transform(
+			pose_data.translation[0],
+			pose_data.translation[1],
+			pose_data.translation[2],
+			pose_data.orientation[0],
+			pose_data.orientation[1],
+			pose_data.orientation[2],
+			pose_data.orientation[3]);
+
+	// Get color camera with respect to imu transformation matrix.
+	frame_pair.base = TANGO_COORDINATE_FRAME_IMU;
+	frame_pair.target = TANGO_COORDINATE_FRAME_CAMERA_DEPTH;
+	ret = TangoService_getPoseAtTime(0.0, frame_pair, &pose_data);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: Failed to get transform between the color camera frame and device frames");
+		return false;
+	}
+	imuTDepthCamera_ = rtabmap::Transform(
+			pose_data.translation[0],
+			pose_data.translation[1],
+			pose_data.translation[2],
+			pose_data.orientation[0],
+			pose_data.orientation[1],
+			pose_data.orientation[2],
+			pose_data.orientation[3]);
+
+	deviceTDepth_ = imuTDevice_.inverse() * imuTDepthCamera_;
+
+	// camera intrinsic
+	TangoCameraIntrinsics color_camera_intrinsics;
+	ret = TangoService_getCameraIntrinsics(TANGO_CAMERA_COLOR, &color_camera_intrinsics);
+	if (ret != TANGO_SUCCESS)
+	{
+		LOGE("NativeRTABMap: Failed to get the intrinsics for the color camera with error code: %d.", ret);
+		return false;
+	}
+	model_ = CameraModel(
+			color_camera_intrinsics.fx,
+			color_camera_intrinsics.fy,
+			color_camera_intrinsics.cx,
+			color_camera_intrinsics.cy,
+			this->getLocalTransform());
+	model_.setImageSize(cv::Size(color_camera_intrinsics.width, color_camera_intrinsics.height));
+
+	// optical rotation
+	model_.setLocalTransform(Transform(
+			0.0f, 0.0f, 1.0f, 0.0f,
+			-1.0f, 0.0f, 0.0f, 0.0f,
+			0.0f, -1.0f, 0.0f, 0.0f));
+
+	return true;
+}
+
+void CameraTango::close()
+{
+	if(tango_config_)
+	{
+		TangoConfig_free(tango_config_);
+		tango_config_ = nullptr;
+		TangoService_disconnect();
+	}
+	firstFrame_ = true;
+}
+
+void CameraTango::cloudReceived(const cv::Mat & cloud, double timestamp)
+{
+	if(this->isRunning())
+	{
+		UASSERT(cloud.type() == CV_32FC3);
+		boost::mutex::scoped_lock  lock(dataMutex_);
+
+		bool notify = cloud_.empty();
+		cloud_ = cloud.clone();
+		cloudStamp_ = timestamp;
+		LOGD("Depth received! (%d points)", cloud.cols);
+		if(!tangoColor_.empty() && notify)
+		{
+			LOGD("Cloud: Release semaphore");
+			dataReady_.release();
+		}
+	}
+}
+
+void CameraTango::rgbReceived(const cv::Mat & tangoImage, int type, double timestamp)
+{
+	if(this->isRunning())
+	{
+		boost::mutex::scoped_lock  lock(dataMutex_);
+
+		if(!cloud_.empty())
+		{
+			if(!tangoImage.empty())
+			{
+				bool notify = tangoColor_.empty();
+				tangoColor_ = tangoImage.clone();
+				tangoColorStamp_ = timestamp;
+				tangoColorType_ = type;
+				LOGD("RGB received!");
+				if(!cloud_.empty() && notify)
+				{
+					LOGD("RGB: Release semaphore");
+					dataReady_.release();
+				}
+			}
+		}
+	}
+}
+
+void CameraTango::poseReceived(const Transform & pose)
+{
+	if(!pose.isNull() && pose.getNormSquared() < 100000)
+	{
+		this->post(new PoseEvent(pose));
+	}
+}
+
+void CameraTango::tangoEventReceived(int type, const char * key, const char * value)
+{
+	this->post(new CameraTangoEvent(type, key, value));
+}
+
+bool CameraTango::isCalibrated() const
+{
+	return model_.isValidForProjection();
+}
+
+std::string CameraTango::getSerial() const
+{
+	return "Tango";
+}
+
+rtabmap::Transform CameraTango::tangoPoseToTransform(const TangoPoseData * tangoPose, bool inOpenGLFrame) const
+{
+	UASSERT(tangoPose);
+	rtabmap::Transform pose;
+	if(!deviceTDepth_.isNull())
+	{
+		pose = rtabmap::Transform(
+				tangoPose->translation[0],
+				tangoPose->translation[1],
+				tangoPose->translation[2],
+				tangoPose->orientation[0],
+				tangoPose->orientation[1],
+				tangoPose->orientation[2],
+				tangoPose->orientation[3]);
+
+		// transform in OpenGL + extrinsics
+		// opengl_world_T_opengl_camera =
+		//      opengl_world_T_start_service *
+		//      start_service_T_device *
+		//      device_T_imu *
+		//      imu_T_depth_camera *
+		//      depth_camera_T_opengl_camera;
+		if(inOpenGLFrame)
+		{
+			pose = opengl_world_T_tango_world * pose * deviceTDepth_ * depth_camera_T_opengl_camera;
+		}
+	}
+
+	return pose;
+}
+
+rtabmap::Transform CameraTango::getPoseAtTimestamp(double timestamp, bool inOpenGLFrame)
+{
+	rtabmap::Transform pose;
+	if(!deviceTDepth_.isNull())
+	{
+		TangoPoseData pose_start_service_T_device;
+		TangoCoordinateFramePair frame_pair;
+		frame_pair.base = TANGO_COORDINATE_FRAME_START_OF_SERVICE;
+		frame_pair.target = TANGO_COORDINATE_FRAME_DEVICE;
+		TangoErrorType status = TangoService_getPoseAtTime(timestamp, frame_pair, &pose_start_service_T_device);
+		if (status != TANGO_SUCCESS)
+		{
+			LOGE(
+				"PoseData: Failed to get transform between the Start of service and "
+				"device frames at timestamp %lf",
+				timestamp);
+		}
+		if (pose_start_service_T_device.status_code != TANGO_POSE_VALID)
+		{
+			LOGW(
+				"PoseData: Failed to get transform between the Start of service and "
+				"device frames at timestamp %lf",
+				timestamp);
+		}
+		else
+		{
+
+			pose = tangoPoseToTransform(&pose_start_service_T_device, inOpenGLFrame);
+		}
+
+
+	}
+	return pose;
+}
+
+SensorData CameraTango::captureImage(CameraInfo * info)
+{
+	LOGI("Capturing image...");
+
+	SensorData data;
+	if(!dataReady_.acquire(1, 2000))
+	{
+		if(this->isRunning())
+		{
+			LOGE("Not received any frames since 2 seconds, try to restart the camera again.");
+			this->post(new CameraTangoEvent(0, "CameraTango", "No frames received since 2 seconds."));
+
+			boost::mutex::scoped_lock  lock(dataMutex_);
+			if(!cloud_.empty() && !tangoColor_.empty())
+			{
+				UERROR("cloud and image were set!?");
+			}
+		}
+		cloud_ = cv::Mat();
+		cloudStamp_ = 0.0;
+		tangoColor_ = cv::Mat();
+		tangoColorStamp_ = 0.0;
+		tangoColorType_ = 0;
+	}
+	else
+	{
+		cv::Mat cloud;
+		cv::Mat tangoImage;
+		cv::Mat rgb;
+		double cloudStamp = 0.0;
+		double rgbStamp = 0.0;
+		int tangoColorType = 0;
+
+		{
+			boost::mutex::scoped_lock  lock(dataMutex_);
+			cloud = cloud_;
+			cloudStamp = cloudStamp_;
+			cloud_ = cv::Mat();
+			cloudStamp_ = 0.0;
+			tangoImage = tangoColor_;
+			rgbStamp = tangoColorStamp_;
+			tangoColorType = tangoColorType_;
+			tangoColor_ = cv::Mat();
+			tangoColorStamp_ = 0.0;
+			tangoColorType_ = 0;
+		}
+
+		if(tangoColorType == TANGO_HAL_PIXEL_FORMAT_RGBA_8888)
+		{
+			cv::cvtColor(tangoImage, rgb, CV_RGBA2BGR);
+		}
+		else if(tangoColorType == TANGO_HAL_PIXEL_FORMAT_YV12)
+		{
+			cv::cvtColor(tangoImage, rgb, CV_YUV2BGR_YV12);
+		}
+		else if(tangoColorType == TANGO_HAL_PIXEL_FORMAT_YCrCb_420_SP)
+		{
+			cv::cvtColor(tangoImage, rgb, CV_YUV2BGR_NV21);
+		}
+		else
+		{
+			LOGE("Not supported color format : %d.", tangoColorType);
+			return data;
+		}
+
+		//for(int i=0; i<rgb.cols; ++i)
+		//{
+		//	UERROR("%d,%d,%d", (int)rgb.at<cv::Vec3b>(i)[0], (int)rgb.at<cv::Vec3b>(i)[1], (int)rgb.at<cv::Vec3b>(i)[2]);
+		//}
+
+		CameraModel model = model_;
+		if(decimation_ > 1)
+		{
+			rgb = util2d::decimate(rgb, decimation_);
+			model = model.scaled(1.0/double(decimation_));
+		}
+
+		// Querying the depth image's frame transformation based on the depth image's
+		// timestamp.
+		cv::Mat depth;
+		Transform poseDepth = getPoseAtTimestamp(cloudStamp, false);
+		Transform poseColor = getPoseAtTimestamp(rgbStamp, false);
+
+		if(poseColor.getNormSquared() > 100000)
+		{
+			LOGE("Very large odometry color pose detected (%s)! Ignoring this frame!", poseColor.prettyPrint().c_str());
+			poseColor.setNull();
+		}
+		if(poseDepth.getNormSquared() > 100000)
+		{
+			LOGE("Very large odometry depth pose detected (%s)! Ignoring this frame!", poseDepth.prettyPrint().c_str());
+			poseDepth.setNull();
+		}
+
+		if(!poseDepth.isNull() && !poseColor.isNull())
+		{
+			// The Color Camera frame at timestamp t0 with respect to Depth
+			// Camera frame at timestamp t1.
+			Transform colorToDepth = deviceTDepth_.inverse() * poseColor.inverse() * poseDepth * deviceTDepth_;
+			LOGI("colorToDepth=%s", colorToDepth.prettyPrint().c_str());
+
+			int pixelsSet = 0;
+			depth = cv::Mat::zeros(model_.imageHeight()/8, model_.imageWidth()/8, CV_16UC1); // mm
+			CameraModel depthModel = model_.scaled(1.0f/8.0f);
+			for(unsigned int i=0; i<cloud.total(); ++i)
+			{
+				cv::Vec3f & p = cloud.at<cv::Vec3f>(i);
+				cv::Point3f pt = util3d::transformPoint(cv::Point3f(p[0], p[1], p[2]), colorToDepth);
+
+				int pixel_x, pixel_y;
+				// get the coordinate on image plane.
+				pixel_x = static_cast<int>((depthModel.fx()) * (pt.x / pt.z) + depthModel.cx());
+				pixel_y = static_cast<int>((depthModel.fy()) * (pt.y / pt.z) + depthModel.cy());
+				unsigned short depth_value(pt.z * 1000.0f);
+
+				if(pixel_x>=0 && pixel_x<depth.cols &&
+				   pixel_y>0 && pixel_y<depth.rows &&
+				   depth_value)
+				{
+					unsigned short & depthPixel = depth.at<unsigned short>(pixel_y, pixel_x);
+					if(depthPixel == 0 || depthPixel > depth_value)
+					{
+						depthPixel = depth_value;
+						pixelsSet += 1;
+					}
+				}
+			}
+			LOGI("pixels depth set= %d", pixelsSet);
+		}
+		else
+		{
+			LOGE("Poses are null?!? color=%d (stamp=%f) depth=%d (stamp=%f)", poseColor.isNull()?0:1, rgbStamp, poseDepth.isNull()?0:1, cloudStamp);
+		}
+
+		if(!rgb.empty() && !depth.empty())
+		{
+			depth = rtabmap::util2d::fillDepthHoles(depth, holeSize, maxDepthError);
+
+			Transform poseColorOpenGL = getPoseAtTimestamp(rgbStamp, true);
+
+			//Rotate in RTAB-Map's coordinate
+			Transform odom = rtabmap_world_T_opengl_world * poseColorOpenGL * depth_camera_T_opengl_camera * model.localTransform().inverse();
+
+			data = SensorData(rgb, depth, model, this->getNextSeqID(), rgbStamp);
+			data.setGroundTruth(odom);
+		}
+		else
+		{
+			LOGE("Could not get depth and rgb images!?!");
+		}
+	}
+	return data;
+
+}
+
+void CameraTango::mainLoopBegin()
+{
+	uSleep(2000); // just to make sure that the camera is started
+}
+
+void CameraTango::mainLoop()
+{
+	if(tango_config_)
+	{
+		SensorData data = this->captureImage();
+
+		if(!data.groundTruth().isNull())
+		{
+			rtabmap::Transform pose = data.groundTruth();
+			data.setGroundTruth(Transform());
+			LOGI("Publish odometry message (variance=%f)", firstFrame_?9999:0.0001);
+			this->post(new OdometryEvent(data, pose, firstFrame_?9999:0.0001, firstFrame_?9999:0.0001));
+			firstFrame_ = false;
+		}
+		else if(!this->isKilled())
+		{
+			LOGW("Odometry lost");
+			this->post(new OdometryEvent());
+		}
+	}
+	else
+	{
+		UERROR("Camera not initialized, cannot start thread.");
+		this->kill();
+	}
+}
+
+} /* namespace rtabmap */

app/android/jni/CameraTango.h

@@ -0,0 +1,116 @@
+/*
+Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef CAMERATANGO_H_
+#define CAMERATANGO_H_
+
+#include <rtabmap/core/Camera.h>
+#include <rtabmap/utilite/UMutex.h>
+#include <rtabmap/utilite/USemaphore.h>
+#include <rtabmap/utilite/UEventsSender.h>
+#include <rtabmap/utilite/UThread.h>
+#include <rtabmap/utilite/UEvent.h>
+#include <boost/thread/mutex.hpp>
+
+class TangoPoseData;
+
+namespace rtabmap {
+
+class PoseEvent: public UEvent
+{
+public:
+	PoseEvent(const Transform & pose) : pose_(pose) {}
+	virtual std::string getClassName() const {return "PoseEvent";}
+	const Transform & pose() const {return pose_;}
+
+private:
+	Transform pose_;
+};
+
+class CameraTangoEvent: public UEvent
+{
+public:
+	CameraTangoEvent(int type, const std::string & key, const std::string & value) : type_(type), key_(key), value_(value) {}
+	virtual std::string getClassName() const {return "CameraTangoEvent";}
+	int type() const {return type_;}
+	const std::string & key() const {return key_;}
+	const std::string & value() const {return value_;}
+
+private:
+	int type_;
+	std::string key_;
+	std::string value_;
+
+};
+
+class CameraTango : public Camera, public UThread, public UEventsSender {
+public:
+	CameraTango(int decimation, bool autoExposure);
+	virtual ~CameraTango();
+
+	virtual bool init(const std::string & calibrationFolder = ".", const std::string & cameraName = "");
+	void close(); // close Tango connection
+	virtual bool isCalibrated() const;
+	virtual std::string getSerial() const;
+	rtabmap::Transform tangoPoseToTransform(const TangoPoseData * tangoPose, bool inOpenGLFrame) const;
+	void setDecimation(int value) {decimation_ = value;}
+	void setAutoExposure(bool enabled) {autoExposure_ = enabled;}
+
+	void cloudReceived(const cv::Mat & cloud, double timestamp);
+	void rgbReceived(const cv::Mat & tangoImage, int type, double timestamp);
+	void poseReceived(const Transform & pose);
+	void tangoEventReceived(int type, const char * key, const char * value);
+
+protected:
+	virtual SensorData captureImage(CameraInfo * info = 0);
+
+private:
+	rtabmap::Transform getPoseAtTimestamp(double timestamp, bool inOpenGLFrame);
+
+	virtual void mainLoopBegin();
+	virtual void mainLoop();
+
+private:
+	void * tango_config_;
+	bool firstFrame_;
+	int decimation_;
+	bool autoExposure_;
+	cv::Mat cloud_;
+	double cloudStamp_;
+	cv::Mat tangoColor_;
+	int tangoColorType_;
+	double tangoColorStamp_;
+	boost::mutex dataMutex_;
+	USemaphore dataReady_;
+	rtabmap::Transform imuTDevice_;
+	rtabmap::Transform imuTDepthCamera_;
+	rtabmap::Transform deviceTDepth_;
+	CameraModel model_;
+};
+
+} /* namespace rtabmap */
+#endif /* CAMERATANGO_H_ */

app/android/jni/RTABMapApp.h

@@ -0,0 +1,192 @@
+/*
+Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef RTABMAP_APP_H_
+#define RTABMAP_APP_H_
+
+#include <jni.h>
+#include <memory>
+
+#include <tango_client_api.h>  // NOLINT
+#include <tango-gl/util.h>
+
+#include <scene.h>
+#include <CameraTango.h>
+#include <util.h>
+
+#include <rtabmap/core/RtabmapThread.h>
+#include <rtabmap/utilite/UEventsHandler.h>
+#include <boost/thread/mutex.hpp>
+#include <pcl/pcl_base.h>
+
+// RTABMapApp handles the application lifecycle and resources.
+class RTABMapApp : public UEventsHandler {
+ public:
+  // Constructor and deconstructor.
+  RTABMapApp();
+  ~RTABMapApp();
+
+  void onCreate(JNIEnv* env, jobject caller_activity);
+
+  void openDatabase(const std::string & databasePath);
+
+  bool onTangoServiceConnected(JNIEnv* env, jobject iBinder);
+
+  // Explicitly reset motion tracking and restart the pipeline.
+  // Note that this will cause motion tracking to re-initialize.
+  void TangoResetMotionTracking();
+
+  // Tango Service point cloud callback function for depth data. Called when new
+  // new point cloud data is available from the Tango Service.
+  //
+  // @param pose: The current point cloud returned by the service,
+  //              caller allocated.
+  void onPointCloudAvailable(const TangoXYZij* xyz_ij);
+
+  // Tango service pose callback function for pose data. Called when new
+  // information about device pose is available from the Tango Service.
+  //
+  // @param pose: The current pose returned by the service, caller allocated.
+  void onPoseAvailable(const TangoPoseData* pose);
+
+  // Tango service event callback function for event data. Called when new events
+  // are available from the Tango Service.
+  //
+  // @param event: Tango event, caller allocated.
+  void onTangoEventAvailable(const TangoEvent* event);
+
+  // Allocate OpenGL resources for rendering, mainly for initializing the Scene.
+  void InitializeGLContent();
+
+  // Setup the view port width and height.
+  void SetViewPort(int width, int height);
+
+  // Main render loop.
+  int Render();
+
+  // Release all non-OpenGL allocated resources.
+  void onPause();
+
+  // Set render camera's viewing angle, first person, third person or top down.
+  //
+  // @param: camera_type, camera type includes first person, third person and
+  //         top down
+  void SetCameraType(tango_gl::GestureCamera::CameraType camera_type);
+
+  // Touch event passed from android activity. This function only supports two
+  // touches.
+  //
+  // @param: touch_count, total count for touches.
+  // @param: event, touch event of current touch.
+  // @param: x0, normalized touch location for touch 0 on x axis.
+  // @param: y0, normalized touch location for touch 0 on y axis.
+  // @param: x1, normalized touch location for touch 1 on x axis.
+  // @param: y1, normalized touch location for touch 1 on y axis.
+  void OnTouchEvent(int touch_count, tango_gl::GestureCamera::TouchEvent event,
+                    float x0, float y0, float x1, float y1);
+
+  void setPausedMapping(bool paused);
+  void setMapCloudShown(bool shown);
+  void setOdomCloudShown(bool shown);
+  void setMeshRendering(bool enabled);
+  void setLocalizationMode(bool enabled);
+  void setTrajectoryMode(bool enabled);
+  void setGraphOptimization(bool enabled);
+  void setNodesFiltering(bool enabled);
+  void setGraphVisible(bool visible);
+  void setAutoExposure(bool enabled);
+  void setFullResolution(bool enabled);
+  void setMaxCloudDepth(float value);
+  void setMeshAngleTolerance(float value);
+  void setMeshTriangleSize(int value);
+  int setMappingParameter(const std::string & key, const std::string & value);
+
+  void resetMapping();
+  void save();
+  bool exportMesh(const std::string & filePath);
+  int postProcessing(int approach);
+
+ protected:
+  virtual void handleEvent(UEvent * event);
+
+ private:
+  rtabmap::ParametersMap getRtabmapParameters();
+
+ private:
+  rtabmap::CameraTango * camera_;
+  rtabmap::RtabmapThread * rtabmapThread_;
+  rtabmap::Rtabmap * rtabmap_;
+  LogHandler * logHandler_;
+
+  bool odomCloudShown_;
+  bool graphOptimization_;
+  bool nodesFiltering_;
+  bool localizationMode_;
+  bool trajectoryMode_;
+  bool autoExposure_;
+  bool fullResolution_;
+  float maxCloudDepth_;
+  int meshTrianglePix_;
+  float meshAngleToleranceDeg_;
+
+  rtabmap::ParametersMap mappingParameters_;
+
+
+  bool clearSceneOnNextRender_;
+  int totalPoints_;
+  int totalPolygons_;
+  int lastDrawnCloudsCount_;
+  float renderingFPS_;
+
+  // main_scene_ includes all drawable object for visualizing Tango device's
+  // movement and point cloud.
+  Scene main_scene_;
+
+	std::list<rtabmap::Statistics> rtabmapEvents_;
+	std::list<rtabmap::OdometryEvent> odomEvents_;
+	std::list<rtabmap::Transform> poseEvents_;
+
+	boost::mutex rtabmapMutex_;
+	boost::mutex meshesMutex_;
+	boost::mutex odomMutex_;
+	boost::mutex poseMutex_;
+
+	struct Mesh
+	{
+		pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud;
+		std::vector<pcl::Vertices> polygons;
+		rtabmap::Transform pose;
+		cv::Mat texture;
+	};
+
+	std::map<int, Mesh> createdMeshes_;
+	std::map<int, rtabmap::Transform> rawPoses_;
+
+	std::pair<rtabmap::RtabmapEventInit::Status, std::string> status_;
+};
+
+#endif  // TANGO_POINT_CLOUD_POINT_CLOUD_APP_H_

app/android/jni/graph_drawable.cpp

@@ -0,0 +1,160 @@
+/*
+Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <sstream>
+
+#include "graph_drawable.h"
+#include "rtabmap/utilite/ULogger.h"
+#include "util.h"
+
+#include <GLES2/gl2.h>
+
+GraphDrawable::GraphDrawable(
+		GLuint shaderProgram,
+		const std::map<int, rtabmap::Transform> & poses,
+		const std::multimap<int, rtabmap::Link> & links) :
+		vertex_buffers_(0),
+		pose_(1.0f),
+		visible_(true),
+		lineWidth_(3.0f),
+		shader_program_(shaderProgram)
+{
+	UASSERT(!poses.empty());
+
+	glGenBuffers(1, &vertex_buffers_);
+
+	if(vertex_buffers_)
+	{
+		LOGI("Creating vertex buffer %d", vertex_buffers_);
+		std::vector<float> vertices = std::vector<float>(poses.size()*3);
+		int i=0;
+		std::map<int, int> idsToIndices;
+		for(std::map<int, rtabmap::Transform>::const_iterator iter=poses.begin(); iter!=poses.end(); ++iter)
+		{
+			vertices[i*3] = iter->second.x();
+			vertices[i*3+1] = iter->second.y();
+			vertices[i*3+2] = iter->second.z();
+			idsToIndices.insert(std::make_pair(iter->first, i));
+			++i;
+		}
+
+		glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_);
+		glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * (int)vertices.size(), (const void *)vertices.data(), GL_STATIC_DRAW);
+		glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+		GLint error = glGetError();
+		if(error != GL_NO_ERROR)
+		{
+			LOGI("OpenGL: Could not allocate point cloud (0x%x)\n", error);
+			vertex_buffers_ = 0;
+		}
+		else if(links.size())
+		{
+			neighborIndices_.resize(links.size() * 2);
+			loopClosureIndices_.resize(links.size() * 2);
+			int oiNeighbors = 0;
+			int oiLoopClosures = 0;
+			for(std::multimap<int, rtabmap::Link>::const_iterator iter=links.begin(); iter!=links.end(); ++iter)
+			{
+				std::map<int, int>::const_iterator jterFrom = idsToIndices.find(iter->second.from());
+				std::map<int, int>::const_iterator jterTo = idsToIndices.find(iter->second.to());
+				if(jterFrom != idsToIndices.end() && jterTo != idsToIndices.end())
+				{
+					if(iter->second.type() == rtabmap::Link::kNeighbor)
+					{
+						neighborIndices_[oiNeighbors++] = (unsigned short)jterFrom->second;
+						neighborIndices_[oiNeighbors++] = (unsigned short)jterTo->second;
+					}
+					else
+					{
+						loopClosureIndices_[oiLoopClosures++] = (unsigned short)jterFrom->second;
+						loopClosureIndices_[oiLoopClosures++] = (unsigned short)jterTo->second;
+					}
+				}
+			}
+			neighborIndices_.resize(oiNeighbors);
+			loopClosureIndices_.resize(oiLoopClosures);
+		}
+	}
+}
+
+GraphDrawable::~GraphDrawable()
+{
+	LOGI("Freeing cloud buffer %d", vertex_buffers_);
+	if (vertex_buffers_)
+	{
+		glDeleteBuffers(1, &vertex_buffers_);
+		tango_gl::util::CheckGlError("GraphDrawable::~GraphDrawable()");
+		vertex_buffers_ = 0;
+	}
+}
+
+void GraphDrawable::setPose(const rtabmap::Transform & pose)
+{
+	UASSERT(!pose.isNull());
+
+	pose_ = glmFromTransform(pose);
+}
+
+void GraphDrawable::Render(const glm::mat4 & projectionMatrix, const glm::mat4 & viewMatrix) {
+
+	if(vertex_buffers_ && (neighborIndices_.size() || loopClosureIndices_.size()) && visible_)
+	{
+		glUseProgram(shader_program_);
+		glLineWidth(lineWidth_);
+
+		GLuint mvp_handle_ = glGetUniformLocation(shader_program_, "mvp");
+		glm::mat4 mvp_mat = projectionMatrix * viewMatrix * pose_;
+		glUniformMatrix4fv(mvp_handle_, 1, GL_FALSE, glm::value_ptr(mvp_mat));
+
+		GLuint color_handle = glGetUniformLocation(shader_program_, "color");
+
+		GLint attribute_vertex = glGetAttribLocation(shader_program_, "vertex");
+
+		glEnableVertexAttribArray(attribute_vertex);
+		glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_);
+		glVertexAttribPointer(attribute_vertex, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), 0);
+
+		if(neighborIndices_.size())
+		{
+			glUniform3f(color_handle, 1.0f, 0.0f, 0.0f); // blue for neighbors
+			glDrawElements(GL_LINES, neighborIndices_.size(), GL_UNSIGNED_SHORT, neighborIndices_.data());
+		}
+		if(loopClosureIndices_.size())
+		{
+			glUniform3f(color_handle, 0.0f, 0.0f, 1.0f); // red for loop closures
+			glDrawElements(GL_LINES, loopClosureIndices_.size(), GL_UNSIGNED_SHORT, loopClosureIndices_.data());
+		}
+
+		glDisableVertexAttribArray(0);
+		glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+		glUseProgram(0);
+		tango_gl::util::CheckGlError("GraphDrawable::Render()");
+	}
+}
+

app/android/jni/graph_drawable.h

@@ -0,0 +1,67 @@
+/*
+Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef GRAPH_DRAWABLE_H_
+#define GRAPH_DRAWABLE_H_
+
+#include <jni.h>
+
+#include <tango-gl/util.h>
+#include <vector>
+#include <pcl/point_cloud.h>
+#include <pcl/point_types.h>
+#include <rtabmap/core/Transform.h>
+#include <rtabmap/core/Link.h>
+#include <pcl/Vertices.h>
+#include "util.h"
+
+class GraphDrawable {
+ public:
+	GraphDrawable(
+		  GLuint shaderProgram,
+		  const std::map<int, rtabmap::Transform> & poses,
+		  const std::multimap<int, rtabmap::Link> & links);
+  virtual ~GraphDrawable();
+
+  void setPose(const rtabmap::Transform & mapToOdom);
+  void setVisible(bool visible) {visible_=visible;}
+
+  void Render(const glm::mat4 & projectionMatrix, const glm::mat4 & viewMatrix);
+
+ private:
+  // Vertex buffer of the point cloud geometry.
+  GLuint vertex_buffers_;
+  std::vector<GLushort> neighborIndices_;
+  std::vector<GLushort> loopClosureIndices_;
+  glm::mat4 pose_;
+  bool visible_;
+  float lineWidth_;
+
+  GLuint shader_program_;
+};
+
+#endif  // GRAPH_DRAWABLE_H_

app/android/jni/jni_interface.cpp

@@ -0,0 +1,244 @@
+/*
+Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#define GLM_FORCE_RADIANS
+
+#include <jni.h>
+#include <RTABMapApp.h>
+#include <scene.h>
+
+static RTABMapApp app;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GetJStringContent(JNIEnv *AEnv, jstring AStr, std::string &ARes) {
+  if (!AStr) {
+    ARes.clear();
+    return;
+  }
+
+  const char *s = AEnv->GetStringUTFChars(AStr,NULL);
+  ARes=s;
+  AEnv->ReleaseStringUTFChars(AStr,s);
+}
+
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_onCreate(
+    JNIEnv* env, jobject, jobject activity)
+{
+	return app.onCreate(env, activity);
+}
+
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_openDatabase(
+    JNIEnv* env, jobject, jstring databasePath)
+{
+	std::string databasePathC;
+	GetJStringContent(env,databasePath,databasePathC);
+	return app.openDatabase(databasePathC);
+}
+
+JNIEXPORT bool JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_onTangoServiceConnected(
+		JNIEnv* env, jobject, jobject iBinder) {
+  return app.onTangoServiceConnected(env, iBinder);
+}
+
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_initGlContent(
+    JNIEnv*, jobject) {
+  app.InitializeGLContent();
+}
+
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setupGraphic(
+    JNIEnv*, jobject, jint width, jint height) {
+  app.SetViewPort(width, height);
+}
+
+JNIEXPORT int JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_render(
+    JNIEnv*, jobject) {
+  return app.Render();
+}
+
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_onPause(
+    JNIEnv*, jobject) {
+  app.onPause();
+}
+
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setCamera(
+    JNIEnv*, jobject, int camera_index) {
+  using namespace tango_gl;
+  GestureCamera::CameraType cam_type =
+      static_cast<GestureCamera::CameraType>(camera_index);
+  app.SetCameraType(cam_type);
+}
+
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_onTouchEvent(
+    JNIEnv*, jobject, int touch_count, int event, float x0, float y0, float x1,
+    float y1) {
+  using namespace tango_gl;
+  GestureCamera::TouchEvent touch_event =
+      static_cast<GestureCamera::TouchEvent>(event);
+  app.OnTouchEvent(touch_count, touch_event, x0, y0, x1, y1);
+}
+
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setPausedMapping(
+		JNIEnv*, jobject, bool paused)
+{
+	return app.setPausedMapping(paused);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setMapCloudShown(
+		JNIEnv*, jobject, bool shown)
+{
+	return app.setMapCloudShown(shown);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setOdomCloudShown(
+		JNIEnv*, jobject, bool shown)
+{
+	return app.setOdomCloudShown(shown);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setMeshRendering(
+		JNIEnv*, jobject, bool enabled)
+{
+	return app.setMeshRendering(enabled);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setLocalizationMode(
+		JNIEnv*, jobject, bool enabled)
+{
+	return app.setLocalizationMode(enabled);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setTrajectoryMode(
+		JNIEnv*, jobject, bool enabled)
+{
+	return app.setTrajectoryMode(enabled);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setGraphOptimization(
+		JNIEnv*, jobject, bool enabled)
+{
+	return app.setGraphOptimization(enabled);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setNodesFiltering(
+		JNIEnv*, jobject, bool enabled)
+{
+	return app.setNodesFiltering(enabled);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setGraphVisible(
+		JNIEnv*, jobject, bool visible)
+{
+	return app.setGraphVisible(visible);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setAutoExposure(
+		JNIEnv*, jobject, bool enabled)
+{
+	return app.setAutoExposure(enabled);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setFullResolution(
+		JNIEnv*, jobject, bool enabled)
+{
+	return app.setFullResolution(enabled);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setMaxCloudDepth(
+		JNIEnv*, jobject, float value)
+{
+	return app.setMaxCloudDepth(value);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setMeshAngleTolerance(
+		JNIEnv*, jobject, float value)
+{
+	return app.setMeshAngleTolerance(value);
+}
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setMeshTriangleSize(
+		JNIEnv*, jobject, int value)
+{
+	return app.setMeshTriangleSize(value);
+}
+JNIEXPORT jint JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_setMappingParameter(
+    JNIEnv* env, jobject, jstring key, jstring value)
+{
+	std::string keyC, valueC;
+	GetJStringContent(env,key,keyC);
+	GetJStringContent(env,value,valueC);
+	return app.setMappingParameter(keyC, valueC);
+}
+
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_resetMapping(
+		JNIEnv*, jobject)
+{
+	return app.resetMapping();
+}
+
+JNIEXPORT void JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_save(
+		JNIEnv* env, jobject)
+{
+	return app.save();
+}
+
+JNIEXPORT bool JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_exportMesh(
+		JNIEnv* env, jobject, jstring filePath)
+{
+	std::string filePathC;
+	GetJStringContent(env,filePath,filePathC);
+	return app.exportMesh(filePathC);
+}
+
+JNIEXPORT int JNICALL
+Java_com_introlab_rtabmap_RTABMapLib_postProcessing(
+		JNIEnv* env, jobject, int approach)
+{
+	return app.postProcessing(approach);
+}
+
+
+
+#ifdef __cplusplus
+}
+#endif

app/android/jni/point_cloud_drawable.cpp

@@ -0,0 +1,257 @@
+/*
+Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <sstream>
+
+#include "point_cloud_drawable.h"
+#include "rtabmap/utilite/ULogger.h"
+#include "rtabmap/utilite/UConversion.h"
+#include <opencv2/imgproc/imgproc.hpp>
+#include "util.h"
+
+#include <GLES2/gl2.h>
+
+PointCloudDrawable::PointCloudDrawable(
+		GLuint cloudShaderProgram,
+		GLuint textureShaderProgram,
+		const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,
+		const std::vector<pcl::Vertices> & polygons,
+		const cv::Mat & image) :
+		vertex_buffers_(0),
+		textures_(0),
+		nPoints_(0),
+		pose_(1.0f),
+		visible_(true),
+		cloud_shader_program_(cloudShaderProgram),
+		texture_shader_program_(textureShaderProgram)
+{
+	UASSERT(!cloud->empty());
+
+	glGenBuffers(1, &vertex_buffers_);
+	if(!vertex_buffers_)
+	{
+		LOGE("OpenGL: could not generate vertex buffers\n");
+		return;
+	}
+
+	if(!cloud->is_dense && !image.empty())
+	{
+		LOGI("cloud=%dx%d image=%dx%d\n", (int)cloud->width, (int)cloud->height, image.cols, image.rows);
+		UASSERT(polygons.size() && !cloud->is_dense && !image.empty() && image.type() == CV_8UC3);
+		glGenTextures(1, &textures_);
+		if(!textures_)
+		{
+			vertex_buffers_ = 0;
+			LOGE("OpenGL: could not generate vertex buffers\n");
+			return;
+		}
+	}
+
+	LOGI("Creating cloud buffer %d", vertex_buffers_);
+	std::vector<float> vertices;
+	if(textures_)
+	{
+		vertices = std::vector<float>(cloud->size()*6);
+		for(unsigned int i=0; i<cloud->size(); ++i)
+		{
+			vertices[i*6] = cloud->at(i).x;
+			vertices[i*6+1] = cloud->at(i).y;
+			vertices[i*6+2] = cloud->at(i).z;
+
+			// rgb
+			vertices[i*6+3] = cloud->at(i).rgb;
+
+			// texture uv
+			vertices[i*6+4] = float(i % cloud->width)/float(cloud->width); //u
+			vertices[i*6+5] = float(i/cloud->width)/float(cloud->height);  //v
+		}
+	}
+	else
+	{
+		vertices = std::vector<float>(cloud->size()*4);
+		for(unsigned int i=0; i<cloud->size(); ++i)
+		{
+			vertices[i*4] = cloud->at(i).x;
+			vertices[i*4+1] = cloud->at(i).y;
+			vertices[i*4+2] = cloud->at(i).z;
+			vertices[i*4+3] = cloud->at(i).rgb;
+		}
+	}
+
+	glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * (int)vertices.size(), (const void *)vertices.data(), GL_STATIC_DRAW);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	GLint error = glGetError();
+	if(error != GL_NO_ERROR)
+	{
+		LOGE("OpenGL: Could not allocate point cloud (0x%x)\n", error);
+		vertex_buffers_ = 0;
+		return;
+	}
+
+	if(textures_)
+	{
+		// gen texture from image
+		glBindTexture(GL_TEXTURE_2D, textures_);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		cv::Mat rgbImage;
+		cv::cvtColor(image, rgbImage, CV_BGR2RGB);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, rgbImage.cols, rgbImage.rows, 0, GL_RGB, GL_UNSIGNED_BYTE, rgbImage.data);
+
+		GLint error = glGetError();
+		if(error != GL_NO_ERROR)
+		{
+			LOGE("OpenGL: Could not allocate texture (0x%x)\n", error);
+			textures_ = 0;
+
+			glDeleteBuffers(1, &vertex_buffers_);
+			vertex_buffers_ = 0;
+			return;
+		}
+	}
+
+	nPoints_ = cloud->size();
+
+	if(polygons.size())
+	{
+		int polygonSize = polygons[0].vertices.size();
+		UASSERT(polygonSize == 3);
+		polygons_.resize(polygons.size() * polygonSize);
+		int oi = 0;
+		for(unsigned int i=0; i<polygons.size(); ++i)
+		{
+			UASSERT((int)polygons[i].vertices.size() == polygonSize);
+			for(int j=0; j<polygonSize; ++j)
+			{
+				polygons_[oi++] = (unsigned short)polygons[i].vertices[j];
+			}
+		}
+	}
+}
+
+PointCloudDrawable::~PointCloudDrawable()
+{
+	LOGI("Freeing cloud buffer %d", vertex_buffers_);
+	if (vertex_buffers_)
+	{
+		glDeleteBuffers(1, &vertex_buffers_);
+		tango_gl::util::CheckGlError("PointCloudDrawable::~PointCloudDrawable()");
+		vertex_buffers_ = 0;
+	}
+
+	if (textures_)
+	{
+		glDeleteTextures(1, &textures_);
+		tango_gl::util::CheckGlError("PointCloudDrawable::~PointCloudDrawable()");
+		textures_ = 0;
+	}
+}
+
+void PointCloudDrawable::setPose(const rtabmap::Transform & pose)
+{
+	UASSERT(!pose.isNull());
+
+	pose_ = glmFromTransform(pose);
+}
+
+void PointCloudDrawable::Render(const glm::mat4 & projectionMatrix, const glm::mat4 & viewMatrix, bool meshRendering, float pointSize) {
+
+	if(vertex_buffers_ && nPoints_ && visible_)
+	{
+		if(meshRendering && textures_)
+		{
+			glUseProgram(texture_shader_program_);
+
+			GLuint mvp_handle_ = glGetUniformLocation(texture_shader_program_, "mvp");
+			glm::mat4 mvp_mat = projectionMatrix * viewMatrix * pose_;
+			glUniformMatrix4fv(mvp_handle_, 1, GL_FALSE, glm::value_ptr(mvp_mat));
+
+			// Texture activate unit 0
+			glActiveTexture(GL_TEXTURE0);
+			// Bind the texture to this unit.
+			glBindTexture(GL_TEXTURE_2D, textures_);
+			// Tell the texture uniform sampler to use this texture in the shader by binding to texture unit 0.
+			GLuint texture_handle = glGetUniformLocation(texture_shader_program_, "u_Texture");
+			glUniform1i(texture_handle, 0);
+
+			GLint attribute_vertex = glGetAttribLocation(texture_shader_program_, "vertex");
+			GLint attribute_texture = glGetAttribLocation(texture_shader_program_, "a_TexCoordinate");
+
+			glEnableVertexAttribArray(attribute_vertex);
+			glEnableVertexAttribArray(attribute_texture);
+			glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_);
+			glVertexAttribPointer(attribute_vertex, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), 0);
+			glVertexAttribPointer(attribute_texture, 2, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), (GLvoid*) (4 * sizeof(GLfloat)));
+
+			glDrawElements(GL_TRIANGLES, polygons_.size(), GL_UNSIGNED_SHORT, polygons_.data());
+		}
+		else // point cloud or colored mesh
+		{
+			glUseProgram(cloud_shader_program_);
+
+			GLuint mvp_handle_ = glGetUniformLocation(cloud_shader_program_, "mvp");
+			glm::mat4 mvp_mat = projectionMatrix * viewMatrix * pose_;
+			glUniformMatrix4fv(mvp_handle_, 1, GL_FALSE, glm::value_ptr(mvp_mat));
+
+			GLuint point_size_handle_ = glGetUniformLocation(cloud_shader_program_, "point_size");
+			glUniform1f(point_size_handle_, pointSize);
+
+			GLint attribute_vertex = glGetAttribLocation(cloud_shader_program_, "vertex");
+			GLint attribute_color = glGetAttribLocation(cloud_shader_program_, "color");
+
+			glEnableVertexAttribArray(attribute_vertex);
+			glEnableVertexAttribArray(attribute_color);
+			glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_);
+			if(textures_)
+			{
+				glVertexAttribPointer(attribute_vertex, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), 0);
+				glVertexAttribPointer(attribute_color, 3, GL_UNSIGNED_BYTE, GL_TRUE, 6*sizeof(GLfloat), (GLvoid*) (3 * sizeof(GLfloat)));
+			}
+			else
+			{
+				glVertexAttribPointer(attribute_vertex, 3, GL_FLOAT, GL_FALSE, 4*sizeof(GLfloat), 0);
+				glVertexAttribPointer(attribute_color, 3, GL_UNSIGNED_BYTE, GL_TRUE, 4*sizeof(GLfloat), (GLvoid*) (3 * sizeof(GLfloat)));
+			}
+			if(meshRendering && polygons_.size())
+			{
+				glDrawElements(GL_TRIANGLES, polygons_.size(), GL_UNSIGNED_SHORT, polygons_.data());
+			}
+			else
+			{
+				glDrawArrays(GL_POINTS, 0, nPoints_);
+			}
+		}
+		glDisableVertexAttribArray(0);
+		glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+		glUseProgram(0);
+		tango_gl::util::CheckGlError("Pointcloud::Render()");
+	}
+}
+

app/android/jni/point_cloud_drawable.h

@@ -0,0 +1,78 @@
+/*
+Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef TANGO_POINT_CLOUD_POINT_CLOUD_DRAWABLE_H_
+#define TANGO_POINT_CLOUD_POINT_CLOUD_DRAWABLE_H_
+
+#include <jni.h>
+
+#include <tango-gl/util.h>
+#include <vector>
+#include <pcl/point_cloud.h>
+#include <pcl/point_types.h>
+#include <rtabmap/core/Transform.h>
+#include <pcl/Vertices.h>
+#include "util.h"
+
+// PointCloudDrawable is responsible for the point cloud rendering.
+class PointCloudDrawable {
+ public:
+  PointCloudDrawable(
+		  GLuint cloudShaderProgram,
+		  GLuint textureShaderProgram,
+  		  const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,
+  		  const std::vector<pcl::Vertices> & polygons = std::vector<pcl::Vertices>(),
+		  const cv::Mat & image = cv::Mat());
+  virtual ~PointCloudDrawable();
+
+  void setPose(const rtabmap::Transform & pose);
+  void setVisible(bool visible) {visible_=visible;}
+  rtabmap::Transform getPose() const {return glmToTransform(pose_);}
+  bool isVisible() const {return visible_;}
+
+  // Update current point cloud data.
+  //
+  // @param projection_mat: projection matrix from current render camera.
+  // @param view_mat: view matrix from current render camera.
+  // @param model_mat: model matrix for this point cloud frame.
+  // @param vertices: all vertices in this point cloud frame.
+  void Render(const glm::mat4 & projectionMatrix, const glm::mat4 & viewMatrix, bool meshRendering = true, float pointSize = 3.0f);
+
+ private:
+  // Vertex buffer of the point cloud geometry.
+  GLuint vertex_buffers_;
+  GLuint textures_;
+  std::vector<GLushort> polygons_;
+  int nPoints_;
+  glm::mat4 pose_;
+  bool visible_;
+
+  GLuint cloud_shader_program_;
+  GLuint texture_shader_program_;
+};
+
+#endif  // TANGO_POINT_CLOUD_POINT_CLOUD_DRAWABLE_H_

app/android/jni/scene.cpp

@@ -0,0 +1,464 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tango-gl/conversions.h>
+#include <tango-gl/gesture_camera.h>
+
+#include <rtabmap/utilite/ULogger.h>
+#include <rtabmap/utilite/UStl.h>
+#include <rtabmap/core/util3d_filtering.h>
+
+#include "scene.h"
+#include "util.h"
+
+// We want to represent the device properly with respect to the ground so we'll
+// add an offset in z to our origin. We'll set this offset to 1.3 meters based
+// on the average height of a human standing with a Tango device. This allows us
+// to place a grid roughly on the ground for most users.
+const glm::vec3 kHeightOffset = glm::vec3(0.0f, 1.3f, 0.0f);
+
+// Color of the motion tracking trajectory.
+const tango_gl::Color kTraceColor(0.66f, 0.66f, 0.66f);
+
+// Color of the ground grid.
+const tango_gl::Color kGridColor(0.85f, 0.85f, 0.85f);
+
+// Frustum scale.
+const glm::vec3 kFrustumScale = glm::vec3(0.4f, 0.3f, 0.5f);
+
+const std::string kPointCloudVertexShader =
+    "precision mediump float;\n"
+    "precision mediump int;\n"
+    "attribute vec3 vertex;\n"
+    "attribute vec3 color;\n"
+    "uniform mat4 mvp;\n"
+    "uniform float point_size;\n"
+    "varying vec3 v_color;\n"
+    "void main() {\n"
+    "  gl_Position = mvp*vec4(vertex.x, vertex.y, vertex.z, 1.0);\n"
+    "  gl_PointSize = point_size;\n"
+    "  v_color = color;\n"
+    "}\n";
+const std::string kPointCloudFragmentShader =
+    "precision mediump float;\n"
+    "precision mediump int;\n"
+    "varying vec3 v_color;\n"
+    "void main() {\n"
+    "  gl_FragColor = vec4(v_color.z, v_color.y, v_color.x, 1.0);\n"
+    "}\n";
+
+const std::string kTextureMeshVertexShader =
+    "precision mediump float;\n"
+    "precision mediump int;\n"
+    "attribute vec3 vertex;\n"
+    "attribute vec2 a_TexCoordinate;\n"
+    "uniform mat4 mvp;\n"
+    "varying vec2 v_TexCoordinate;\n"
+    "void main() {\n"
+    "  gl_Position = mvp*vec4(vertex.x, vertex.y, vertex.z, 1.0);\n"
+    "  v_TexCoordinate = a_TexCoordinate;\n"
+    "}\n";
+const std::string kTextureMeshFragmentShader =
+    "precision mediump float;\n"
+    "precision mediump int;\n"
+	"uniform sampler2D u_Texture;\n"
+    "varying vec2 v_TexCoordinate;\n"
+    "void main() {\n"
+    "  gl_FragColor = texture2D(u_Texture, v_TexCoordinate);\n"
+    "}\n";
+
+const std::string kGraphVertexShader =
+    "precision mediump float;\n"
+    "precision mediump int;\n"
+    "attribute vec3 vertex;\n"
+    "uniform vec3 color;\n"
+    "uniform mat4 mvp;\n"
+    "varying vec3 v_color;\n"
+    "void main() {\n"
+    "  gl_Position = mvp*vec4(vertex.x, vertex.y, vertex.z, 1.0);\n"
+    "  v_color = color;\n"
+    "}\n";
+const std::string kGraphFragmentShader =
+    "precision mediump float;\n"
+    "precision mediump int;\n"
+    "varying vec3 v_color;\n"
+    "void main() {\n"
+    "  gl_FragColor = vec4(v_color.z, v_color.y, v_color.x, 1.0);\n"
+    "}\n";
+
+
+
+Scene::Scene() :
+		gesture_camera_(0),
+		axis_(0),
+		frustum_(0),
+		grid_(0),
+		trace_(0),
+		graph_(0),
+		graphVisible_(true),
+		traceVisible_(true),
+		currentPose_(0),
+		cloud_shader_program_(0),
+		texture_mesh_shader_program_(0),
+		graph_shader_program_(0),
+		mapRendering_(true),
+		meshRendering_(true),
+		pointSize_(3.0f) {}
+
+Scene::~Scene() {DeleteResources();}
+
+//Should only be called in OpenGL thread!
+void Scene::InitGLContent()
+{
+	if(gesture_camera_ != 0)
+	{
+		DeleteResources();
+	}
+
+	UASSERT(gesture_camera_ == 0);
+
+  gesture_camera_ = new tango_gl::GestureCamera();
+  axis_ = new tango_gl::Axis();
+  frustum_ = new tango_gl::Frustum();
+  trace_ = new tango_gl::Trace();
+  grid_ = new tango_gl::Grid();
+  currentPose_ = new rtabmap::Transform();
+
+
+  axis_->SetScale(glm::vec3(0.5f,0.5f,0.5f));
+  frustum_->SetColor(kTraceColor);
+  trace_->ClearVertexArray();
+  trace_->SetColor(kTraceColor);
+  grid_->SetColor(kGridColor);
+  grid_->SetPosition(-kHeightOffset);
+  gesture_camera_->SetCameraType(
+      tango_gl::GestureCamera::kFirstPerson);
+
+  if(cloud_shader_program_ == 0)
+  {
+	  cloud_shader_program_ = tango_gl::util::CreateProgram(kPointCloudVertexShader.c_str(), kPointCloudFragmentShader.c_str());
+	  UASSERT(cloud_shader_program_ != 0);
+  }
+  if(texture_mesh_shader_program_ == 0)
+  {
+	  texture_mesh_shader_program_ = tango_gl::util::CreateProgram(kTextureMeshVertexShader.c_str(), kTextureMeshFragmentShader.c_str());
+	  UASSERT(texture_mesh_shader_program_ != 0);
+  }
+  if(graph_shader_program_ == 0)
+  {
+	  graph_shader_program_ = tango_gl::util::CreateProgram(kGraphVertexShader.c_str(), kGraphFragmentShader.c_str());
+	  UASSERT(graph_shader_program_ != 0);
+  }
+}
+
+//Should only be called in OpenGL thread!
+void Scene::DeleteResources() {
+
+	LOGI("Scene::DeleteResources()");
+	if(gesture_camera_)
+	{
+	  delete gesture_camera_;
+	  delete axis_;
+	  delete frustum_;
+	  delete trace_;
+	  delete grid_;
+	  delete currentPose_;
+	  gesture_camera_ = 0;
+	}
+
+	if (cloud_shader_program_) {
+		glDeleteShader(cloud_shader_program_);
+		cloud_shader_program_ = 0;
+	  }
+	if (texture_mesh_shader_program_) {
+		glDeleteShader(texture_mesh_shader_program_);
+		texture_mesh_shader_program_ = 0;
+	  }
+	if (graph_shader_program_) {
+		glDeleteShader(graph_shader_program_);
+		graph_shader_program_ = 0;
+	  }
+
+	clear();
+}
+
+//Should only be called in OpenGL thread!
+void Scene::clear()
+{
+	LOGI("Scene::clear()");
+	for(std::map<int, PointCloudDrawable*>::iterator iter=pointClouds_.begin(); iter!=pointClouds_.end(); ++iter)
+	{
+		delete iter->second;
+	}
+	if(trace_)
+	{
+		trace_->ClearVertexArray();
+	}
+	if(graph_)
+	{
+		delete graph_;
+		graph_ = 0;
+	}
+	pointClouds_.clear();
+}
+
+//Should only be called in OpenGL thread!
+void Scene::SetupViewPort(int w, int h) {
+  if (h == 0) {
+    LOGE("Setup graphic height not valid");
+  }
+  UASSERT(gesture_camera_ != 0);
+  gesture_camera_->SetAspectRatio(static_cast<float>(w) /
+                                  static_cast<float>(h));
+  glViewport(0, 0, w, h);
+}
+
+//Should only be called in OpenGL thread!
+int Scene::Render() {
+	UASSERT(gesture_camera_ != 0);
+
+  glEnable(GL_DEPTH_TEST);
+  glEnable(GL_CULL_FACE);
+
+  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+  glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+
+  if(!currentPose_->isNull())
+  {
+	  glm::vec3 position(currentPose_->x(), currentPose_->y(), currentPose_->z());
+	  Eigen::Quaternionf quat = currentPose_->getQuaternionf();
+	  glm::quat rotation(quat.w(), quat.x(), quat.y(), quat.z());
+
+	  if (gesture_camera_->GetCameraType() == tango_gl::GestureCamera::kFirstPerson)
+	  {
+		// In first person mode, we directly control camera's motion.
+		gesture_camera_->SetPosition(position);
+		gesture_camera_->SetRotation(rotation);
+	  }
+	  else
+	  {
+		// In third person or top down more, we follow the camera movement.
+		gesture_camera_->SetAnchorPosition(position, rotation);
+
+		frustum_->SetPosition(position);
+		frustum_->SetRotation(rotation);
+		// Set the frustum scale to 4:3, this doesn't necessarily match the physical
+		// camera's aspect ratio, this is just for visualization purposes.
+		frustum_->SetScale(kFrustumScale);
+		frustum_->Render(gesture_camera_->GetProjectionMatrix(),
+						 gesture_camera_->GetViewMatrix());
+
+		axis_->SetPosition(position);
+		axis_->SetRotation(rotation);
+		axis_->Render(gesture_camera_->GetProjectionMatrix(),
+					  gesture_camera_->GetViewMatrix());
+	  }
+
+	  trace_->UpdateVertexArray(position);
+	  if(traceVisible_)
+	  {
+		  trace_->Render(gesture_camera_->GetProjectionMatrix(),
+						 gesture_camera_->GetViewMatrix());
+	  }
+  }
+
+
+	grid_->Render(gesture_camera_->GetProjectionMatrix(),
+				  gesture_camera_->GetViewMatrix());
+
+	bool frustumCulling = true;
+	int cloudDrawn=0;
+	if(mapRendering_ && frustumCulling)
+	{
+		//Use camera frustum to cull nodes that don't need to be drawn
+		pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
+		std::vector<int> ids(pointClouds_.size());
+
+		cloud->resize(pointClouds_.size());
+		ids.resize(pointClouds_.size());
+		int oi=0;
+		for(std::map<int, PointCloudDrawable*>::const_iterator iter=pointClouds_.begin(); iter!=pointClouds_.end(); ++iter)
+		{
+			if(!iter->second->getPose().isNull() && iter->second->isVisible())
+			{
+				(*cloud)[oi] = pcl::PointXYZ(iter->second->getPose().x(), iter->second->getPose().y(), iter->second->getPose().z());
+				ids[oi++] = iter->first;
+			}
+		}
+		cloud->resize(oi);
+		ids.resize(oi);
+
+		if(oi)
+		{
+			float fov = 45.0f;
+			rtabmap::Transform openglCamera = GetOpenGLCameraPose(&fov)*rtabmap::Transform(0.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f);
+			// transform in same coordinate as frustum filtering
+			openglCamera *= rtabmap::Transform(
+				 0.0f,  0.0f,  1.0f, 0.0f,
+				 0.0f,  1.0f,  0.0f, 0.0f,
+				-1.0f,  0.0f,  0.0f, 0.0f);
+			pcl::IndicesPtr indices = rtabmap::util3d::frustumFiltering(
+					cloud,
+					pcl::IndicesPtr(new std::vector<int>),
+					openglCamera,
+					fov*2.0f,
+					fov*2.0f,
+					0.1f,
+					100.0f);
+
+			//LOGI("Frustum poses filtered = %d (showing %d/%d)",
+			//			(int)(pointClouds_.size()-indices->size()),
+			//			(int)indices->size(),
+			//			(int)pointClouds_.size());
+
+			for(unsigned int i=0; i<indices->size(); ++i)
+			{
+				++cloudDrawn;
+				pointClouds_.find(ids[indices->at(i)])->second->Render(gesture_camera_->GetProjectionMatrix(), gesture_camera_->GetViewMatrix(), meshRendering_, pointSize_);
+			}
+		}
+	}
+	else
+	{
+		for(std::map<int, PointCloudDrawable*>::const_iterator iter=pointClouds_.begin(); iter!=pointClouds_.end(); ++iter)
+		{
+			if((mapRendering_ || iter->first < 0) && iter->second->isVisible())
+			{
+				++cloudDrawn;
+				iter->second->Render(gesture_camera_->GetProjectionMatrix(), gesture_camera_->GetViewMatrix(), meshRendering_, pointSize_);
+			}
+		}
+	}
+
+	if(graphVisible_ && graph_)
+	{
+		graph_->Render(gesture_camera_->GetProjectionMatrix(), gesture_camera_->GetViewMatrix());
+	}
+
+	return cloudDrawn;
+}
+
+void Scene::SetCameraType(tango_gl::GestureCamera::CameraType camera_type) {
+  gesture_camera_->SetCameraType(camera_type);
+}
+
+void Scene::SetCameraPose(const rtabmap::Transform & pose)
+{
+	UASSERT(currentPose_ != 0);
+	UASSERT(!pose.isNull());
+	*currentPose_ = pose;
+}
+
+rtabmap::Transform Scene::GetOpenGLCameraPose(float * fov) const
+{
+	if(fov)
+	{
+		*fov = gesture_camera_->getFOV();
+	}
+	return glmToTransform(gesture_camera_->GetTransformationMatrix());
+
+}
+
+void Scene::OnTouchEvent(int touch_count,
+                         tango_gl::GestureCamera::TouchEvent event, float x0,
+                         float y0, float x1, float y1) {
+	UASSERT(gesture_camera_ != 0);
+  gesture_camera_->OnTouchEvent(touch_count, event, x0, y0, x1, y1);
+}
+
+void Scene::updateGraph(
+		const std::map<int, rtabmap::Transform> & poses,
+		const std::multimap<int, rtabmap::Link> & links)
+{
+	LOGI("updateGraph");
+	if(graph_)
+	{
+		delete graph_;
+		graph_ = 0;
+	}
+
+	//create
+	UASSERT(graph_shader_program_ != 0);
+	graph_ = new GraphDrawable(graph_shader_program_, poses, links);
+}
+
+void Scene::setGraphVisible(bool visible)
+{
+	graphVisible_ = visible;
+}
+
+void Scene::setTraceVisible(bool visible)
+{
+	traceVisible_ = visible;
+}
+
+//Should only be called in OpenGL thread!
+void Scene::addCloud(
+		int id,
+		const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,
+		const std::vector<pcl::Vertices> & polygons,
+		const rtabmap::Transform & pose,
+		const cv::Mat & image)
+{
+	LOGI("addOrUpdateCloud cloud %d", id);
+	std::map<int, PointCloudDrawable*>::iterator iter=pointClouds_.find(id);
+	if(iter != pointClouds_.end())
+	{
+		delete iter->second;
+		pointClouds_.erase(iter);
+	}
+
+	//create
+	UASSERT(cloud_shader_program_ != 0 && texture_mesh_shader_program_!=0);
+	PointCloudDrawable * drawable = new PointCloudDrawable(
+			cloud_shader_program_,
+			texture_mesh_shader_program_,
+			cloud,
+			polygons,
+			image);
+	drawable->setPose(pose);
+	pointClouds_.insert(std::make_pair(id, drawable));
+}
+
+
+void Scene::setCloudPose(int id, const rtabmap::Transform & pose)
+{
+	UASSERT(!pose.isNull());
+	std::map<int, PointCloudDrawable*>::iterator iter=pointClouds_.find(id);
+	if(iter != pointClouds_.end())
+	{
+		iter->second->setPose(pose);
+	}
+}
+
+void Scene::setCloudVisible(int id, bool visible)
+{
+	std::map<int, PointCloudDrawable*>::iterator iter=pointClouds_.find(id);
+	if(iter != pointClouds_.end())
+	{
+		iter->second->setVisible(visible);
+	}
+}
+
+bool Scene::hasCloud(int id) const
+{
+	return pointClouds_.find(id) != pointClouds_.end();
+}
+
+std::set<int> Scene::getAddedClouds() const
+{
+	return uKeysSet(pointClouds_);
+}

app/android/jni/scene.h

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_POINT_CLOUD_SCENE_H_
+#define TANGO_POINT_CLOUD_SCENE_H_
+
+#include <jni.h>
+#include <memory>
+#include <set>
+
+#include <tango_client_api.h>  // NOLINT
+#include <tango-gl/axis.h>
+#include <tango-gl/camera.h>
+#include <tango-gl/color.h>
+#include <tango-gl/gesture_camera.h>
+#include <tango-gl/grid.h>
+#include <tango-gl/frustum.h>
+#include <tango-gl/trace.h>
+#include <tango-gl/transform.h>
+#include <tango-gl/util.h>
+
+#include <rtabmap/core/Transform.h>
+#include <rtabmap/core/Link.h>
+
+#include <point_cloud_drawable.h>
+#include <graph_drawable.h>
+
+#include <pcl/point_cloud.h>
+#include <pcl/point_types.h>
+
+// Scene provides OpenGL drawable objects and renders them for visualization.
+class Scene {
+ public:
+  // Constructor and destructor.
+  Scene();
+  ~Scene();
+
+  // Allocate OpenGL resources for rendering.
+  void InitGLContent();
+
+  // Release non-OpenGL allocated resources.
+  void DeleteResources();
+
+  // Setup GL view port.
+  void SetupViewPort(int w, int h);
+
+  void clear(); // removed all point clouds
+
+  // Render loop.
+  // @param: cur_pose_transformation, latest pose's transformation.
+  // @param: point_cloud_transformation, pose transformation at point cloud
+  //         frame's timestamp.
+  // @param: point_cloud_vertices, point cloud's vertices of the current point
+  //         frame.
+  int Render();
+
+  // Set render camera's viewing angle, first person, third person or top down.
+  //
+  // @param: camera_type, camera type includes first person, third person and
+  //         top down
+  void SetCameraType(tango_gl::GestureCamera::CameraType camera_type);
+
+  void SetCameraPose(const rtabmap::Transform & pose);
+  rtabmap::Transform GetCameraPose() const {return currentPose_!=0?*currentPose_:rtabmap::Transform();}
+  rtabmap::Transform GetOpenGLCameraPose(float * fov) const;
+
+  // Touch event passed from android activity. This function only support two
+  // touches.
+  //
+  // @param: touch_count, total count for touches.
+  // @param: event, touch event of current touch.
+  // @param: x0, normalized touch location for touch 0 on x axis.
+  // @param: y0, normalized touch location for touch 0 on y axis.
+  // @param: x1, normalized touch location for touch 1 on x axis.
+  // @param: y1, normalized touch location for touch 1 on y axis.
+  void OnTouchEvent(int touch_count, tango_gl::GestureCamera::TouchEvent event,
+                    float x0, float y0, float x1, float y1);
+
+  void updateGraph(
+  		const std::map<int, rtabmap::Transform> & poses,
+  		const std::multimap<int, rtabmap::Link> & links);
+
+  void setGraphVisible(bool visible);
+  void setTraceVisible(bool visible);
+
+  void addCloud(
+  		  int id,
+  		  const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,
+  		  const std::vector<pcl::Vertices> & polygons,
+  		  const rtabmap::Transform & pose,
+		  const cv::Mat & image = cv::Mat());
+
+  void setCloudPose(int id, const rtabmap::Transform & pose);
+  void setCloudVisible(int id, bool visible);
+  bool hasCloud(int id) const;
+  std::set<int> getAddedClouds() const;
+
+  void setMapRendering(bool enabled) {mapRendering_ = enabled;}
+  void setMeshRendering(bool enabled) {meshRendering_ = enabled;}
+  void setPointSize(float size) {pointSize_ = size;}
+
+ private:
+  // Camera object that allows user to use touch input to interact with.
+  tango_gl::GestureCamera* gesture_camera_;
+
+  // Device axis (in device frame of reference).
+  tango_gl::Axis* axis_;
+
+  // Device frustum.
+  tango_gl::Frustum* frustum_;
+
+  // Ground grid.
+  tango_gl::Grid* grid_;
+
+  // Trace of pose data.
+  tango_gl::Trace* trace_;
+  GraphDrawable * graph_;
+  bool graphVisible_;
+  bool traceVisible_;
+
+  std::map<int, PointCloudDrawable*> pointClouds_;
+
+  rtabmap::Transform * currentPose_;
+
+  // Shader to display point cloud.
+  GLuint cloud_shader_program_;
+  GLuint texture_mesh_shader_program_;
+  GLuint graph_shader_program_;
+
+  bool mapRendering_;
+  bool meshRendering_;
+  float pointSize_;
+};
+
+#endif  // TANGO_POINT_CLOUD_SCENE_H_

app/android/jni/tango-gl/axis.cpp

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/axis.h"
+#include "tango-gl/shaders.h"
+
+namespace tango_gl {
+
+static const float float_vertices[] = {0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
+                                       0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
+                                       0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+
+static const float float_colors[] = {
+    1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f,
+    0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f};
+
+Axis::Axis() : Line(3.0f, GL_LINES) {
+  // Implement SetShader here, not using the dedault one.
+  shader_program_ =
+      util::CreateProgram(shaders::GetColorVertexShader().c_str(),
+                          shaders::GetBasicFragmentShader().c_str());
+  if (!shader_program_) {
+    LOGE("Could not create program.");
+  }
+  uniform_mvp_mat_ = glGetUniformLocation(shader_program_, "mvp");
+  attrib_colors_ = glGetAttribLocation(shader_program_, "color");
+  attrib_vertices_ = glGetAttribLocation(shader_program_, "vertex");
+
+  size_t size = sizeof(float_vertices) / (sizeof(float) * 3);
+  for (size_t i = 0; i < size; i++) {
+    vec_vertices_.push_back(glm::vec3(float_vertices[i * 3],
+                                      float_vertices[i * 3 + 1],
+                                      float_vertices[i * 3 + 2]));
+    vec_colors_.push_back(
+        glm::vec4(float_colors[i * 4], float_colors[i * 4 + 1],
+                  float_colors[i * 4 + 2], float_colors[i * 4 + 3]));
+  }
+}
+
+void Axis::Render(const glm::mat4& projection_mat,
+                  const glm::mat4& view_mat) const {
+  glUseProgram(shader_program_);
+  glLineWidth(line_width_);
+  glm::mat4 model_mat = GetTransformationMatrix();
+  glm::mat4 mvp_mat = projection_mat * view_mat * model_mat;
+  glUniformMatrix4fv(uniform_mvp_mat_, 1, GL_FALSE, glm::value_ptr(mvp_mat));
+
+  glEnableVertexAttribArray(attrib_vertices_);
+  glVertexAttribPointer(attrib_vertices_, 3, GL_FLOAT, GL_FALSE,
+                        sizeof(glm::vec3), &vec_vertices_[0]);
+
+  glEnableVertexAttribArray(attrib_colors_);
+  glVertexAttribPointer(attrib_colors_, 4, GL_FLOAT, GL_FALSE,
+                        sizeof(glm::vec4), &vec_colors_[0]);
+
+  glDrawArrays(render_mode_, 0, vec_vertices_.size());
+
+  glDisableVertexAttribArray(attrib_vertices_);
+  glDisableVertexAttribArray(attrib_colors_);
+  glUseProgram(0);
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/band.cpp

@@ -0,0 +1,149 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/band.h"
+#include "tango-gl/util.h"
+
+namespace tango_gl {
+
+// Set band resolution to 0.01m(1cm) when using UpdateVertexArray()
+static const float kMinDistanceSquared = 0.0001f;
+
+Band::Band(const unsigned int max_length)
+    : band_width_(0.2), max_length_(max_length) {
+  SetShader();
+  vertices_v_.reserve(max_length);
+  pivot_left = glm::vec3(0, 0, 0);
+  pivot_right = glm::vec3(0, 0, 0);
+}
+
+void Band::SetWidth(const float width) {
+  band_width_ = width;
+}
+
+void Band::UpdateVertexArray(const glm::mat4 m, BandMode mode) {
+  // First 2 vertices of a band + 3 arrow head vertices.
+  bool need_to_initialize = (vertices_v_.size() < 5);
+
+  bool sufficient_delta = false;
+  if (!need_to_initialize) {
+    // Band head is the first two vertices after arrow head.
+    glm::vec3 band_front = 0.5f * (vertices_v_[vertices_v_.size() - 4] +
+                                   vertices_v_[vertices_v_.size() - 5]);
+    sufficient_delta = kMinDistanceSquared <
+        util::DistanceSquared(band_front, util::GetTranslationFromMatrix(m));
+  }
+
+  if (need_to_initialize || sufficient_delta) {
+    glm::vec3 left  = glm::vec3(-band_width_ * 0.5f, 0, 0);
+    glm::vec3 right = glm::vec3(band_width_ * 0.5f, 0, 0);
+    glm::vec3 arrow_left = glm::vec3(-band_width_ * 0.75f, 0, 0);
+    glm::vec3 arrow_right = glm::vec3(band_width_ * 0.75f, 0, 0);
+    glm::vec3 arrow_front = glm::vec3(0, 0, -band_width_ * 0.75f);
+
+    // If keep right pivot point, or normal mode,
+    // then only update left pivot point.
+    if (mode == BandMode::kNormal || mode == BandMode::kKeepRight) {
+      pivot_left = util::ApplyTransform(m, left);
+    }
+    // If keep left pivot point, or normal mode,
+    // then only update right pivot point.
+    if (mode == BandMode::kNormal || mode == BandMode::kKeepLeft) {
+      pivot_right = util::ApplyTransform(m, right);
+    }
+
+    glm::mat4 head_m = m;
+
+    if (mode != BandMode::kNormal) {
+      glm::vec3 up = glm::vec3(0, 1.0f, 0);
+      glm::vec3 position = 0.5f * (pivot_left + pivot_right);
+      glm::vec3 heading = glm::cross(up, pivot_right-pivot_left);
+      head_m = glm::inverse(glm::lookAt(glm::vec3(0, 0, 0), heading, up));
+      head_m[3][0] = position.x;
+      head_m[3][1] = position.y;
+      head_m[3][2] = position.z;
+    }
+
+    if (need_to_initialize) {
+      vertices_v_.resize(5);
+    } else {
+      vertices_v_.resize(vertices_v_.size() + 2);
+    }
+
+    size_t insertion_start = vertices_v_.size() - 5;
+    vertices_v_[insertion_start + 0] = pivot_left;
+    vertices_v_[insertion_start + 1] = pivot_right;
+    vertices_v_[insertion_start + 2] = util::ApplyTransform(head_m, arrow_left);
+    vertices_v_[insertion_start + 3] = util::ApplyTransform(head_m, arrow_right);
+    vertices_v_[insertion_start + 4] = util::ApplyTransform(head_m, arrow_front);
+
+    if (vertices_v_.size() > max_length_) {
+      vertices_v_.erase(vertices_v_.begin(), vertices_v_.begin() + 2);
+    }
+  }
+}
+
+void Band::UpdateVertexArray(const glm::mat4 m) {
+  // Defualt to call update with normal mode.
+  UpdateVertexArray(m, BandMode::kNormal);
+}
+
+void Band::SetVertexArray(const std::vector<glm::vec3>& v,
+                          const glm::vec3& up) {
+  vertices_v_.clear();
+  vertices_v_.reserve(2 * v.size());
+  if (v.size() < 2)
+    return;
+
+  for (size_t i = 0; i < v.size() - 1; ++i) {
+    glm::vec3 gl_p_world_a = v[i];
+    glm::vec3 gl_p_world_b = v[i + 1];
+    glm::vec3 dir = glm::normalize(gl_p_world_b - gl_p_world_a);
+    glm::vec3 left = glm::cross(up, dir);
+    glm::normalize(left);
+
+    vertices_v_.push_back(gl_p_world_a + (band_width_ / 2.0f * left));
+    vertices_v_.push_back(gl_p_world_a - (band_width_ / 2.0f * left));
+
+    // Cap the end of the path.
+    if (i == v.size() - 2) {
+      vertices_v_.push_back(gl_p_world_b + (band_width_ / 2.0f * left));
+      vertices_v_.push_back(gl_p_world_b - (band_width_ / 2.0f * left));
+    }
+  }
+
+}
+
+void Band::ClearVertexArray() { vertices_v_.clear(); }
+
+void Band::Render(const glm::mat4& projection_mat,
+                  const glm::mat4& view_mat) const {
+  glUseProgram(shader_program_);
+  glm::mat4 model_mat = GetTransformationMatrix();
+  glm::mat4 mvp_mat = projection_mat * view_mat * model_mat;
+  glUniformMatrix4fv(uniform_mvp_mat_, 1, GL_FALSE, glm::value_ptr(mvp_mat));
+
+  glUniform4f(uniform_color_, red_, green_, blue_, alpha_);
+
+  glEnableVertexAttribArray(attrib_vertices_);
+  glVertexAttribPointer(attrib_vertices_, 3, GL_FLOAT, GL_FALSE,
+                        sizeof(glm::vec3), &vertices_v_[0]);
+  glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices_v_.size());
+  glDisableVertexAttribArray(attrib_vertices_);
+  glUseProgram(0);
+}
+
+}  // namespace tango_gl

app/android/jni/tango-gl/bounding_box.cpp

@@ -0,0 +1,62 @@
+#include "tango-gl/bounding_box.h"
+
+namespace tango_gl {
+BoundingBox::BoundingBox(const std::vector<float>& vertices) {
+  // Set min and max to the first vertice.
+  bounding_min_ = glm::vec3(vertices[0], vertices[1], vertices[2]);
+  bounding_max_ = bounding_min_;
+  size_t vertices_count = vertices.size() / 3;
+  for (size_t i = 1; i < vertices_count; i += 3) {
+    bounding_min_.x = std::min(vertices[i * 3], bounding_min_.x);
+    bounding_min_.y = std::min(vertices[i * 3 + 1], bounding_min_.y);
+    bounding_min_.z = std::min(vertices[i * 3 + 2], bounding_min_.z);
+
+    bounding_max_.x = std::max(vertices[i * 3], bounding_max_.x);
+    bounding_max_.y = std::max(vertices[i * 3 + 1], bounding_max_.y);
+    bounding_max_.z = std::max(vertices[i * 3 + 2], bounding_max_.z);
+  }
+}
+
+bool BoundingBox::IsIntersecting(const Segment& segment,
+                                 const glm::quat& rotation,
+                                 const glm::mat4& transformation) {
+  // The current bounding box.
+  glm::vec3 min, max;
+
+  // If the mesh has been rotated, we need to derive a new bounding box
+  // based on the original one, if it just been translated or scaled,
+  // we can still use the original one with current model matrix applied.
+  if (rotation == glm::quat(1.0f, 0.0f, 0.0f, 0.0f)) {
+    min = util::ApplyTransform(transformation, bounding_min_);
+    max = util::ApplyTransform(transformation, bounding_max_);
+  } else {
+    std::vector<glm::vec3> box;
+    // Derive 8 vertices of the new bounding box from original min and max.
+    box.push_back(bounding_min_);
+    box.push_back(bounding_max_);
+
+    box.push_back(glm::vec3(bounding_min_.x, bounding_max_.y, bounding_max_.z));
+    box.push_back(glm::vec3(bounding_max_.x, bounding_min_.y, bounding_min_.z));
+
+    box.push_back(glm::vec3(bounding_min_.x, bounding_min_.y, bounding_max_.z));
+    box.push_back(glm::vec3(bounding_max_.x, bounding_max_.y, bounding_min_.z));
+
+    box.push_back(glm::vec3(bounding_max_.x, bounding_min_.y, bounding_max_.z));
+    box.push_back(glm::vec3(bounding_min_.x, bounding_max_.y, bounding_min_.z));
+
+    min = util::ApplyTransform(transformation, bounding_min_);
+    max = min;
+    for (size_t i = 1; i < box.size(); i++) {
+      glm::vec3 temp = util::ApplyTransform(transformation, box[i]);
+      min.x = std::min(temp.x, min.x);
+      min.y = std::min(temp.y, min.y);
+      min.z = std::min(temp.z, min.z);
+
+      max.x = std::max(temp.x, max.x);
+      max.y = std::max(temp.y, max.y);
+      max.z = std::max(temp.z, max.z);
+    }
+  }
+  return util::SegmentAABBIntersect(min, max, segment.start, segment.end);
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/camera.cpp

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/camera.h"
+#include "tango-gl/util.h"
+
+namespace tango_gl {
+
+Camera::Camera() {
+  field_of_view_ = 45.0f * DEGREE_2_RADIANS;
+  aspect_ratio_ = 4.0f / 3.0f;
+  near_clip_plane_ = 0.1f;
+  far_clip_plane_ = 100.0f;
+}
+
+glm::mat4 Camera::GetViewMatrix() {
+  return glm::inverse(GetTransformationMatrix());
+}
+
+glm::mat4 Camera::GetProjectionMatrix() {
+  return glm::perspective(field_of_view_, aspect_ratio_,
+                          near_clip_plane_, far_clip_plane_);
+}
+
+void Camera::SetAspectRatio(float aspect_ratio) {
+  aspect_ratio_ = aspect_ratio;
+}
+
+void Camera::SetFieldOfView(float fov) {
+  field_of_view_ = fov * DEGREE_2_RADIANS;
+}
+
+Camera::~Camera() {
+}
+
+glm::mat4 Camera::ProjectionMatrixForCameraIntrinsics(float width, float height,
+                                                      float fx, float fy,
+                                                      float cx, float cy,
+                                                      float near, float far) {
+  const float xscale = near / fx;
+  const float yscale = near / fy;
+
+  const float xoffset =  (cx - (width  / 2.0)) * xscale;
+  // Color camera's coordinates has y pointing downwards so we negate this term.
+  const float yoffset = -(cy - (height / 2.0)) * yscale;
+
+  return  glm::frustum(xscale * -width  / 2.0f - xoffset,
+                       xscale *  width  / 2.0f - xoffset,
+                       yscale * -height / 2.0f - yoffset,
+                       yscale *  height / 2.0f - yoffset,
+                       near, far);
+}
+
+}  // namespace tango_gl

app/android/jni/tango-gl/circle.cpp

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/circle.h"
+
+namespace tango_gl {
+Circle::Circle(float radius, int resolution) : Mesh(GL_TRIANGLE_FAN){
+  SetShader();
+  std::vector<GLfloat> vertices;
+  vertices.reserve(3 * (resolution + 2));
+  vertices.push_back(0);
+  vertices.push_back(0);
+  vertices.push_back(0);
+  float delta_theta = M_PI * 2.0f / static_cast<float>(resolution);
+  for (int i = resolution; i >= 0; i--) {
+    float theta = delta_theta * static_cast<float>(i);
+    vertices.push_back(cos(theta) * radius);
+    vertices.push_back(0);
+    vertices.push_back(sin(theta) * radius);
+  }
+  SetVertices(vertices);
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/conversions.cpp

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/conversions.h"
+
+namespace tango_gl {
+namespace conversions {
+
+glm::mat4 opengl_world_T_tango_world() {
+  // Note glm is column-wise.
+  return glm::mat4(1.0f, 0.0f,  0.0f, 0.0f,
+                   0.0f, 0.0f, -1.0f, 0.0f,
+                   0.0f, 1.0f,  0.0f, 0.0f,
+                   0.0f, 0.0f,  0.0f, 1.0f);
+}
+
+glm::mat4 color_camera_T_opengl_camera() {
+  // Note glm is column-wise.
+  return glm::mat4(1.0f,  0.0f,  0.0f, 0.0f,
+                   0.0f, -1.0f,  0.0f, 0.0f,
+                   0.0f,  0.0f, -1.0f, 0.0f,
+                   0.0f,  0.0f,  0.0f, 1.0f);
+}
+
+glm::mat4 depth_camera_T_opengl_camera() {
+  // Note glm is column-wise.
+  return glm::mat4(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+                   -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f);
+}
+
+glm::quat QuatTangoToGl(const glm::quat& tango_q_frame) {
+  const float kSqrt2Over2 = std::sqrt(2.0) / 2.0f;
+  // Tango frame is a -90 degree rotation about +X from the GL frame.
+  glm::quat gl_q_tango = glm::quat(kSqrt2Over2, -kSqrt2Over2, 0.0f, 0.0f);
+  return gl_q_tango * tango_q_frame;
+}
+
+}  // namespace gl_tango_conversions
+}  // namespace tango_gl

app/android/jni/tango-gl/cube.cpp

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/cube.h"
+
+namespace tango_gl {
+
+static const GLfloat const_vertices[] = {
+    -1.0f, 1.0f,  1.0f,  -1.0f, -1.0f, 1.0f,  1.0f,  1.0f,  1.0f,  -1.0f, -1.0f,
+    1.0f,  1.0f,  -1.0f, 1.0f,  1.0f,  1.0f,  1.0f,  1.0f,  1.0f,  1.0f,  1.0f,
+    -1.0f, 1.0f,  1.0f,  1.0f,  -1.0f, 1.0f,  -1.0f, 1.0f,  1.0f,  -1.0f, -1.0f,
+    1.0f,  1.0f,  -1.0f, 1.0f,  1.0f,  -1.0f, 1.0f,  -1.0f, -1.0f, -1.0f, 1.0f,
+    -1.0f, 1.0f,  -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f,  -1.0f, -1.0f,
+    1.0f,  -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f,  1.0f,  -1.0f, -1.0f, -1.0f,
+    -1.0f, -1.0f, 1.0f,  -1.0f, 1.0f,  1.0f,  -1.0f, 1.0f,  -1.0f, -1.0f, 1.0f,
+    1.0f,  1.0f,  1.0f,  -1.0f, -1.0f, 1.0f,  1.0f,  1.0f,  1.0f,  1.0f,  1.0f,
+    1.0f,  -1.0f, 1.0f,  -1.0f, -1.0f, 1.0f,  -1.0f, 1.0f,  -1.0f, -1.0f, -1.0f,
+    1.0f,  -1.0f, 1.0f,  -1.0f, -1.0f, 1.0f,  -1.0f, -1.0f, -1.0f};
+
+static const GLfloat const_normals[] = {
+    0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,
+    1.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f,
+    0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,
+    1.0f,  0.0f,  0.0f,  0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,
+    -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,  -1.0f, -1.0f,
+    0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,
+    -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,
+    0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,
+    1.0f,  0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,
+    0.0f,  -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f};
+
+Cube::Cube() {
+  SetShader(true);
+  std::vector<GLfloat> vertices(
+      const_vertices,
+      const_vertices + sizeof(const_vertices) / sizeof(GLfloat));
+  std::vector<GLfloat> normals(
+      const_normals, const_normals + sizeof(const_normals) / sizeof(GLfloat));
+  SetVertices(vertices, normals);
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/drawable_object.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/drawable_object.h"
+#include "tango-gl/shaders.h"
+
+namespace tango_gl {
+
+void DrawableObject::SetShader() {
+  shader_program_ =
+      util::CreateProgram(shaders::GetBasicVertexShader().c_str(),
+                          shaders::GetBasicFragmentShader().c_str());
+  if (!shader_program_) {
+    LOGE("Could not create program.");
+  }
+  uniform_mvp_mat_ = glGetUniformLocation(shader_program_, "mvp");
+  attrib_vertices_ = glGetAttribLocation(shader_program_, "vertex");
+  uniform_color_ = glGetUniformLocation(shader_program_, "color");
+}
+
+void DrawableObject::DeleteGlResources() {
+  if (shader_program_) {
+    glDeleteShader(shader_program_);
+  }
+}
+
+void DrawableObject::SetColor(float red, float green, float blue) {
+  red_ = red;
+  green_ = green;
+  blue_ = blue;
+}
+void DrawableObject::SetColor(const Color& color) {
+  SetColor(color.r, color.g, color.b);
+}
+
+void DrawableObject::SetAlpha(const float alpha) { alpha_ = alpha; }
+
+void DrawableObject::SetVertices(const std::vector<GLfloat>& vertices) {
+  vertices_ = vertices;
+}
+
+void DrawableObject::SetVertices(const std::vector<GLfloat>& vertices,
+                                 const std::vector<GLushort>& indices) {
+  vertices_ = vertices;
+  indices_ = indices;
+}
+
+void DrawableObject::SetVertices(const std::vector<GLfloat>& vertices,
+                                 const std::vector<GLfloat>& normals) {
+  vertices_ = vertices;
+  normals_ = normals;
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/frustum.cpp

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "tango-gl/frustum.h"
+
+namespace tango_gl {
+
+static const float float_vertices[] = {
+    0.0f,  0.0f,  0.0f,  -1.0f, 1.0f,  -1.0f, 0.0f,  0.0f,  0.0f,  1.0f,
+    1.0f,  -1.0f, 0.0f,  0.0f,  0.0f,  -1.0f, -1.0f, -1.0f, 0.0f,  0.0f,
+    0.0f,  1.0f,  -1.0f, -1.0f, -1.0f, 1.0f,  -1.0f, 1.0f,  1.0f,  -1.0f,
+    1.0f,  1.0f,  -1.0f, 1.0f,  -1.0f, -1.0f, 1.0f,  -1.0f, -1.0f, -1.0f,
+    -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f,  -1.0f};
+
+Frustum::Frustum() : Line(3.0f, GL_LINES) {
+  SetShader();
+  size_t size = sizeof(float_vertices) / sizeof(float);
+  for (size_t i = 0; i < size; i += 3) {
+    vec_vertices_.push_back(glm::vec3(float_vertices[i], float_vertices[i + 1],
+                                      float_vertices[i + 2]));
+  }
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/gesture_camera.cpp

@@ -0,0 +1,187 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/gesture_camera.h"
+#include "tango-gl/util.h"
+
+namespace {
+// Render camera observation distance in third person camera mode.
+const float kThirdPersonCameraDist = 7.0f;
+
+// Render camera observation distance in third person camera mode.
+const float kThirdPersonFollowCameraDist = 2.0f;
+
+// Render camera observation distance in top down camera mode.
+const float kTopDownCameraDist = 5.0f;
+
+// Zoom in speed.
+const float kZoomSpeed = 10.0f;
+
+// Min/max clamp value of camera observation distance.
+const float kCamViewMinDist = 1.0f;
+const float kCamViewMaxDist = 100.f;
+
+// FOV set up values.
+// Third and top down camera's FOV is 65 degrees.
+// First person camera's FOV is 45 degrees.
+const float kHighFov = 65.0f;
+const float kLowFov = 65.0f;
+}
+
+namespace tango_gl {
+
+GestureCamera::GestureCamera() :
+		cam_cur_target_rot_(1,0,0,0),
+		start_touch_dist_(0.0f),
+		cur_touch_dist_(0.0f)
+{
+  cam_parent_transform_ = new Transform();
+  SetParent(cam_parent_transform_);
+}
+
+GestureCamera::~GestureCamera() { delete cam_parent_transform_; }
+
+void GestureCamera::OnTouchEvent(int touch_count, TouchEvent event, float x0,
+                                 float y0, float x1, float y1) {
+  if (camera_type_ == kFirstPerson) {
+    return;
+  }
+
+  if (touch_count == 1) {
+    switch (event) {
+      case kTouch0Down: {
+        cam_start_angle_ = cam_cur_angle_;
+
+        touch0_start_position_.x = x0;
+        touch0_start_position_.y = y0;
+        break;
+      }
+      case kTouchMove: {
+        float rotation_x = touch0_start_position_.y - y0;
+        float rotation_y = touch0_start_position_.x - x0;
+
+        cam_cur_angle_.x = cam_start_angle_.x + rotation_x;
+        cam_cur_angle_.y = cam_start_angle_.y + rotation_y;
+        StartCameraToCurrentTransform();
+        break;
+      }
+      default: { break; }
+    }
+  }
+  if (touch_count == 2) {
+    switch (event) {
+      case kTouch1Down: {
+        float abs_x = x0 - x1;
+        float abs_y = y0 - y1;
+        start_touch_dist_ = std::sqrt(abs_x * abs_x + abs_y * abs_y);
+        cam_start_dist_ = GetPosition().z;
+        break;
+      }
+      case kTouchMove: {
+        float abs_x = x0 - x1;
+        float abs_y = y0 - y1;
+        float dist =
+            start_touch_dist_ - std::sqrt(abs_x * abs_x + abs_y * abs_y);
+        cam_cur_dist_ =
+            tango_gl::util::Clamp(cam_start_dist_ + dist * kZoomSpeed,
+                                  kCamViewMinDist, kCamViewMaxDist);
+        StartCameraToCurrentTransform();
+        break;
+      }
+      default: { break; }
+    }
+  }
+}
+
+Segment GestureCamera::GetSegmentFromTouch(float normalized_x,
+                                           float normalized_y,
+                                           float touch_range) {
+  float screen_height = touch_range * (2.0f * glm::tan(field_of_view_ * 0.5f));
+  float screen_width = screen_height * aspect_ratio_;
+  // normalized_x and normalized_x are from OnTouchEvent, top-left corner of the
+  // screen
+  // is [0, 0], transform it to opengl frame.
+  normalized_x = normalized_x - 0.5f;
+  normalized_y = 0.5f - normalized_y;
+  glm::vec3 start =
+      util::ApplyTransform(GetTransformationMatrix(), glm::vec3(0, 0, 0));
+  glm::vec3 end = util::ApplyTransform(GetTransformationMatrix(), 
+      glm::vec3(normalized_x * screen_width, normalized_y * screen_height,
+                -touch_range));
+  Segment segment(start, end);
+  return segment;
+}
+
+void GestureCamera::SetAnchorPosition(const glm::vec3& pos, const glm::quat & rotation) {
+	cam_parent_transform_->SetPosition(pos);
+	if(camera_type_ == kThirdPersonFollow)
+	{
+		cam_cur_target_rot_ = rotation;
+		cam_cur_target_rot_.x = 0;
+		cam_cur_target_rot_.z = 0;
+		cam_cur_target_rot_ = glm::normalize(cam_cur_target_rot_);
+		StartCameraToCurrentTransform();
+	}
+}
+
+void GestureCamera::SetCameraType(CameraType camera_index) {
+  camera_type_ = camera_index;
+  switch (camera_index) {
+    case kFirstPerson:
+      SetFieldOfView(kLowFov);
+      SetPosition(glm::vec3(0.0f, 0.0f, 0.0f));
+      SetRotation(glm::quat(1.0f, 0.0f, 0.0f, 0.0f));
+      cam_cur_dist_ = 0.0f;
+      cam_cur_angle_.x = 0.0f;
+      cam_cur_angle_.y = 0.0f;
+      cam_cur_target_rot_ = glm::quat(1,0,0,0);
+      cam_parent_transform_->SetPosition(glm::vec3(0.0f, 0.0f, 0.0f));
+      StartCameraToCurrentTransform();
+      break;
+    case kThirdPerson:
+    case kThirdPersonFollow:
+      SetFieldOfView(kHighFov);
+      SetPosition(glm::vec3(0.0f, 0.0f, 0.0f));
+      SetRotation(glm::quat(1.0f, 0.0f, 0.0f, 0.0f));
+      cam_cur_dist_ = kThirdPersonFollow?kThirdPersonFollowCameraDist:kThirdPersonCameraDist;
+      cam_cur_angle_.x = -M_PI / 4.0f;
+      cam_cur_angle_.y = kThirdPersonFollow?0:M_PI / 4.0f;
+      cam_cur_target_rot_ = glm::quat(1,0,0,0);
+      StartCameraToCurrentTransform();
+      break;
+    case kTopDown:
+      SetFieldOfView(kHighFov);
+      SetPosition(glm::vec3(0.0f, 0.0f, 0.0f));
+      SetRotation(glm::quat(1.0f, 0.0f, 0.0f, 0.0f));
+      cam_cur_dist_ = kTopDownCameraDist;
+      cam_cur_angle_.x = -M_PI / 2.0f;
+      cam_cur_angle_.y = 0.0f;
+      cam_cur_target_rot_ = glm::quat(1,0,0,0);
+      StartCameraToCurrentTransform();
+      break;
+    default:
+      break;
+  }
+}
+
+void GestureCamera::StartCameraToCurrentTransform()
+{
+  glm::quat parent_cam_rot = glm::rotate(cam_cur_target_rot_, cam_cur_angle_.y, glm::vec3(0, 1, 0));
+  parent_cam_rot = glm::rotate(parent_cam_rot, cam_cur_angle_.x, glm::vec3(1, 0, 0));
+  SetPosition(glm::vec3(0.0f, 0.0f, cam_cur_dist_));
+  cam_parent_transform_->SetRotation(parent_cam_rot);
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/goal_marker.cpp

@@ -0,0 +1,59 @@
+
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ * Distributed under the Project Tango Preview Development Kit (PDK) Agreement.
+ * CONFIDENTIAL. AUTHORIZED USE ONLY. DO NOT REDISTRIBUTE.
+ */
+
+#include "tango-gl/goal_marker.h"
+
+namespace tango_gl {
+
+static const GLfloat const_vertices[] = {
+    -4.5298f,  -0.2676f,  0.0,       -4.3209f,  -1.3857f,  0.0,      -3.7242f,
+    -11.1445f, 0.0,       -5.6799f,  -8.9811f,  0.0,       -4.4540f, 0.8673f,
+    0.0,       -7.8376f,  -6.4508f,  0.0,       -9.5223f,  -3.0538f, 0.0,
+    -9.9826f,  -0.5898f,  0.0,       -9.8157f,  1.9113f,   0.0,      -9.0320f,
+    4.2923f,   0.0,       -7.6808f,  6.4036f,   0.0,       -5.8469f, 8.1125f,
+    0.0,       -3.6457f,  9.3117f,   0.0,       -4.0984f,  1.9477f,  0.0,
+    -1.2155f,  9.9259f,   0.0,       -3.4853f,  2.9057f,   0.0,      1.2912f,
+    9.9163f,   0.0,       -2.6532f,  3.6812f,   0.0,       3.7167f,  9.2837f,
+    0.0,       -1.6543f,  4.2254f,   0.0,       5.9087f,   8.0677f,  0.0,
+    -0.5515f,  4.5040f,   0.0,       7.7294f,   6.3448f,   0.0,      0.5859f,
+    4.4997f,   0.0,       9.0645f,   4.2232f,   0.0,       1.6865f,  4.2126f,
+    0.0,       9.8300f,   1.8363f,   0.0,       2.6812f,   3.6609f,  0.0,
+    9.9778f,   -0.6660f,  0.0,       3.5074f,   2.8791f,   0.0,      9.4987f,
+    -3.1264f,  0.0,       4.1132f,   1.9164f,   0.0,       7.7964f,  -6.5204f,
+    0.0,       4.4605f,   0.8333f,   0.0,       5.6245f,   -9.0444f, 0.0,
+    4.5276f,   -0.3022f,  0.0,       3.6572f,   -11.1925f, 0.0,      4.3102f,
+    -1.4187f,  0.0,       1.5165f,   -13.5960f, 0.0,       3.8220f,  -2.4460f,
+    0.0,       -0.0382f,  -16.4245f, 0.0,       3.0936f,   -3.3197f, 0.0,
+    -1.5902f,  -13.5657f, 0.0,       2.1709f,   -3.9847f,  0.0,      -3.8405f,
+    -2.4168f,  0.0,       -3.1189f,  -3.2959f,  0.0,       -2.2012f, -3.9680f,
+    0.0,       -1.1452f,  -4.3908f,  0.0,       -0.0173f,  -4.5377f, 0.0,
+    1.1117f,   -4.3994f,  0.0};
+
+static const GLushort const_indices[] = {
+    1,  2,  3,  1,  3,  4,  5,  1,  4,  4,  6,  7,  5,  4,  7,  7,  8,  9,  9,
+    10, 11, 7,  9,  11, 5,  7,  11, 5,  11, 12, 5,  12, 13, 14, 5,  13, 14, 13,
+    15, 16, 14, 15, 16, 15, 17, 18, 16, 17, 18, 17, 19, 20, 18, 19, 20, 19, 21,
+    22, 20, 21, 22, 21, 23, 24, 22, 23, 24, 23, 25, 26, 24, 25, 26, 25, 27, 28,
+    26, 27, 28, 27, 29, 30, 28, 29, 30, 29, 31, 32, 30, 31, 32, 31, 33, 34, 32,
+    33, 34, 33, 35, 36, 34, 35, 36, 35, 37, 38, 36, 37, 38, 37, 39, 40, 38, 39,
+    40, 39, 41, 42, 40, 41, 42, 41, 43, 44, 42, 43, 44, 43, 3,  3,  2,  45, 3,
+    45, 46, 3,  46, 47, 3,  47, 48, 3,  48, 49, 3,  49, 50, 44, 3,  50};
+
+GoalMarker::GoalMarker() {
+  SetShader();
+  std::vector<GLfloat> vertices(
+      const_vertices,
+      const_vertices + sizeof(const_vertices) / sizeof(GLfloat));
+  std::vector<GLushort> indices(
+      const_indices, const_indices + sizeof(const_indices) / sizeof(GLushort));
+  // Change indices so they are zero-indexed.
+  for (size_t i = 0; i < indices.size(); ++i) {
+    indices[i] = indices[i] - 1;
+  }
+  SetVertices(vertices, indices);
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/grid.cpp

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/grid.h"
+
+namespace tango_gl {
+
+// Initialize Grid with x and y grid count,
+// qx, quantity in x
+// qy, quantity in y.
+Grid::Grid(float density, int qx, int qy) : Line(1.0f, GL_LINES) {
+  SetShader();
+
+  // 3 float in 1 vertex, 2 vertices form a line.
+  // Horizontal line and vertical line forms the grid.
+  float width = density * qx / 2;
+  float height = density * qy / 2;
+
+  // Horizontal line.
+  for (int i = 0; i < (qy + 1); i++) {
+    vec_vertices_.push_back(glm::vec3(-width, 0.0f, -height + i * density));
+    vec_vertices_.push_back(glm::vec3(width, 0.0f, -height + i * density));
+  }
+
+  for (int i = 0; i < (qx + 1); i++) {
+    vec_vertices_.push_back(glm::vec3(-width + i * density, 0.0f, -height));
+    vec_vertices_.push_back(glm::vec3(-width + i * density, 0.0f, height));
+  }
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/include/tango-gl/axis.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_AXIS_H_
+#define TANGO_GL_AXIS_H_
+
+#include "tango-gl/line.h"
+
+namespace tango_gl {
+class Axis : public Line {
+ public:
+  Axis();
+  void Render(const glm::mat4& projection_mat, const glm::mat4& view_mat) const;
+ private:
+  GLuint attrib_colors_;
+  std::vector<glm::vec4> vec_colors_;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_AXIS_H_

app/android/jni/tango-gl/include/tango-gl/band.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_BAND_H_
+#define TANGO_GL_BAND_H_
+
+#include <stdlib.h>
+#include <vector>
+
+#include "tango-gl/drawable_object.h"
+
+namespace tango_gl {
+class Band : public DrawableObject {
+ public:
+  enum BandMode {
+    kNormal = 0,
+    kKeepLeft = 1,
+    kKeepRight = 2
+  };
+
+  Band(const unsigned int max_legnth);
+
+  void SetWidth(const float width);
+  // Render a Band with arrow head, pass in the mode for rendering,
+  // kKeepLeft is left turn, kKeepRight is right turn,
+  // when making a turn, vertices only get updated in one side to avoid overlapping.
+  void UpdateVertexArray(const glm::mat4 m, BandMode mode);
+  void UpdateVertexArray(const glm::mat4 m);
+  void SetVertexArray(const std::vector<glm::vec3>& v, const glm::vec3& up);
+  void ClearVertexArray();
+  void Render(const glm::mat4& projection_mat, const glm::mat4& view_mat) const;
+
+ private:
+  float band_width_;
+  unsigned int max_length_;
+  std::vector<glm::vec3> vertices_v_;
+  // Current band head's left and right position in world frame.
+  glm::vec3 pivot_left;
+  glm::vec3 pivot_right;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_BAND_H_

app/android/jni/tango-gl/include/tango-gl/bounding_box.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_BOUNDING_BOX_H_
+#define TANGO_GL_BOUNDING_BOX_H_
+
+#include <vector>
+
+#include "tango-gl/segment.h"
+#include "tango-gl/util.h"
+
+namespace tango_gl {
+class BoundingBox {
+ public:
+  BoundingBox()
+      : bounding_min_(glm::vec3(0, 0, 0)), bounding_max_(glm::vec3(0, 0, 0)) {}
+  BoundingBox(const std::vector<float>& vertices);
+  BoundingBox(const glm::vec3& min, const glm::vec3& max)
+      : bounding_min_(min), bounding_max_(max) {}
+  bool IsIntersecting(const Segment& segment, const glm::quat& rotation,
+                      const glm::mat4& transformation);
+
+ private:
+  // Axis-aligned bounding box minimum and maximum point.
+  glm::vec3 bounding_min_;
+  glm::vec3 bounding_max_;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_BOUNDING_BOX_H_

app/android/jni/tango-gl/include/tango-gl/camera.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_CAMERA_H_
+#define TANGO_GL_CAMERA_H_
+
+#include "tango-gl/transform.h"
+
+namespace tango_gl {
+class Camera : public Transform {
+ public:
+  Camera();
+  Camera(const Camera& other) = delete;
+  Camera& operator=(const Camera&) = delete;
+  ~Camera();
+
+  void SetAspectRatio(const float aspect_ratio);
+  void SetFieldOfView(const float fov);
+
+  glm::mat4 GetViewMatrix();
+  glm::mat4 GetProjectionMatrix();
+
+  /**
+   * Create an OpenGL perspective matrix from window size, camera intrinsics, and clip settings.
+   *
+   * @param width  - The width of the camera image.
+   * @param height - The height of the camera image.
+   * @param fx     - The x-axis focal length of the camera.
+   * @param fy     - The y-axis focal length of the camera.
+   * @param cx     - The x-coordinate principal point in pixels.
+   * @param cy     - The y-coordinate principal point in pixels.
+   * @param near   - The desired near z-clipping plane.
+   * @param far    - The desired far z-clipping plane.
+   */
+  static glm::mat4 ProjectionMatrixForCameraIntrinsics(float width, float height,
+                                                       float fx,    float fy,
+                                                       float cx,    float cy,
+                                                       float near,  float far);
+ protected:
+  float field_of_view_;
+  float aspect_ratio_;
+  float near_clip_plane_, far_clip_plane_;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_CAMERA_H_

app/android/jni/tango-gl/include/tango-gl/circle.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_CIRCLE_H_
+#define TANGO_GL_CIRCLE_H_
+
+#include "tango-gl/mesh.h"
+
+namespace tango_gl {
+class Circle : public Mesh {
+ public:
+  Circle(float radius, int resolution);
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_CIRCLE_H_

app/android/jni/tango-gl/include/tango-gl/color.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_COLOR_H_
+#define TANGO_GL_COLOR_H_
+
+namespace tango_gl {
+class Color {
+ public:
+  Color() : r(0), g(0), b(0) {}
+  Color(float red, float green, float blue) : r(red), g(green), b(blue) {}
+  Color(const Color&) = default;
+  Color& operator=(const Color&) = default;
+
+  float r;
+  float g;
+  float b;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_COLOR_H_

app/android/jni/tango-gl/include/tango-gl/conversions.h

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_GL_TANGO_CONVERSIONS_H_
+#define TANGO_GL_GL_TANGO_CONVERSIONS_H_
+
+#define GLM_FORCE_RADIANS
+
+#include "glm/glm.hpp"
+#include "glm/gtc/matrix_transform.hpp"
+#include "glm/gtc/quaternion.hpp"
+
+namespace tango_gl {
+namespace conversions {
+
+/**
+ * @brief Creates a glm::vec3 from double[3] = {x, y, z}. This is designed to
+ * work with the TangoPoseData.translation field.
+ */
+inline glm::vec3 Vec3FromArray(const double* array) {
+  return glm::vec3(array[0], array[1], array[2]);
+}
+
+/**
+ * @brief Creates a glm::quat from double[4] = {x, y, z, w}. This is designed to
+ * work with the TangoPoseData.orientation field.
+ */
+inline glm::quat QuatFromArray(const double* array) {
+  // Note GLM expects arguments in order {w, x, y, z}.
+  return glm::quat(array[3], array[0], array[1], array[2]);
+}
+
+/**
+ * @brief Creates a glm::mat4 rigid-frame transformation matrix from two arrays.
+ * This is designed for the TangoPoseData translation and orientation fields.
+ * @param A_p_B Position [x, y, z] of B_origin from A_origin, expressed in A.
+ * @param A_q_B The quaternion representation [x, y, z, w] of the rotation
+ * matrix A_R_B.
+ * @return The transformation matrix A_T_B.
+ */
+inline glm::mat4 TransformFromArrays(const double* A_p_B, const double* A_q_B) {
+  glm::vec3 glm_A_p_B = Vec3FromArray(A_p_B);
+  glm::quat glm_A_q_B = QuatFromArray(A_q_B);
+  return glm::translate(glm::mat4(1.0f), glm_A_p_B) * glm::mat4_cast(glm_A_q_B);
+}
+
+/**
+ * @brief Creates a glm::mat4 rigid-frame transformation matrix from glm::vec3 and glm::quat.
+ * This is designed for the TangoPoseData translation and orientation fields.
+ * @param A_p_B A position vector of B_origin from A_origin, expressed in A.
+ * @param A_q_B A quaternion representation of the rotation.
+ * matrix A_R_B.
+ * @return The transformation matrix A_T_B.
+ */
+inline glm::mat4 TransformFromVecAndQuat(const glm::vec3& A_p_B, const glm::quat& A_q_B) {
+  return glm::translate(glm::mat4(1.0f), A_p_B) * glm::mat4_cast(A_q_B);
+}
+
+/**
+ * @brief Convert (re-express, or rotate) a vector from the Tango ADF (or start-
+ * of-service) frame convention [right, forward, up] to the typical OpenGl world
+ * frame convention [right, up, backward]. Note this assumes the two frames are
+ * coincident, and it doesn't know about any additional offsets between a
+ * particular OpenGl scene and the Tango service frames.
+ * @param tango_vec A vector expressed in the Tango ADF frame convention.
+ * @return The same vector expressed using the Opengl frame convention.
+ */
+inline glm::vec3 Vec3TangoToGl(const glm::vec3& tango_vec) {
+  return glm::vec3(tango_vec.x, tango_vec.z, -tango_vec.y);
+}
+
+/**
+ * @brief Convert (re-express, or rotate) a vector from the typical OpenGl world
+ * frame convention [right, up, backward] to the Tango ADF (or start-of-service)
+ * frame convention [right, forward, up]. Note this assumes the two frames are
+ * coincident, and it doesn't know about any additional offsets between a
+ * particular OpenGl scene and the Tango service frames.
+ * @param gl_vec A vector expressed in the Opengl world frame convention.
+ * @return The same vector expressed using the Tango ADF frame convention.
+ */
+inline glm::vec3 Vec3GlToTango(const glm::vec3& gl_vec) {
+  return glm::vec3(gl_vec.x, -gl_vec.z, gl_vec.y);
+}
+
+/**
+ * @brief Given a quaternion representing the rotation matrix tango_R_any,
+ * returns the quaternion representing gl_R_any, where "any" is an arbitrary
+ * frame. Note the gl base frame is rotated by 90-degrees about +X from the
+ * Tango ADF/start-of-service frame, so this is equivalent to applying such a
+ * rotation to the quaternion.
+ * @param tango_q_any A quaternion representing rotation matrix tango_R_any.
+ * @return The quaternion representing gl_R_any.
+ */
+glm::quat QuatTangoToGl(const glm::quat& tango_q_any);
+
+/**
+ * Get the fixed transformation matrix relating the opengl frame convention
+ * (with Y-up, X-right) and the tango frame convention for the start-of-service
+ * and ADF frames (with Z-up, X-right), termed "world" here.
+ */
+glm::mat4 opengl_world_T_tango_world();
+
+/**
+ * Get the fixed transformation matrix relating the frame convention of the
+ * device's color camera frame (with Z-forward, X-right) and the opengl camera
+ * frame (with Z-backward, X-right).
+ */
+glm::mat4 color_camera_T_opengl_camera();
+
+/**
+ * Get the fixed transformation matrix relating the frame convention of the
+ * device's depth camera frame (with Z-forward, X-right) and the opengl camera
+ * frame (with Z-backward, X-right).
+ */
+glm::mat4 depth_camera_T_opengl_camera();
+
+}  // namespace conversions
+}  // namespace tango_gl
+#endif  // TANGO_GL_GL_TANGO_CONVERSIONS_H_

app/android/jni/tango-gl/include/tango-gl/cube.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_CUBE_H_
+#define TANGO_GL_CUBE_H_
+
+#include "tango-gl/mesh.h"
+
+namespace tango_gl {
+class Cube : public Mesh {
+ public:
+  Cube();
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_CUBE_H_

app/android/jni/tango-gl/include/tango-gl/drawable_object.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_DRAWABLE_OBJECT_H_
+#define TANGO_GL_DRAWABLE_OBJECT_H_
+
+#include <vector>
+
+#include "tango-gl/color.h"
+#include "tango-gl/transform.h"
+#include "tango-gl/util.h"
+
+namespace tango_gl {
+class DrawableObject : public Transform {
+ public:
+  DrawableObject() : red_(0), green_(0), blue_(0), alpha_(1.0f) {};
+  DrawableObject(const DrawableObject& other) = delete;
+  const DrawableObject& operator=(const DrawableObject&) = delete;
+
+  void DeleteGlResources();
+  void SetShader();
+  void SetColor(const Color& color);
+  void SetColor(const float red, const float green, const float blue);
+  void SetAlpha(const float alpha);
+  void SetVertices(const std::vector<GLfloat>& vertices);
+  void SetVertices(const std::vector<GLfloat>& vertices,
+                   const std::vector<GLushort>& indices);
+  void SetVertices(const std::vector<GLfloat>& vertices,
+                   const std::vector<GLfloat>& normals);
+  virtual void Render(const glm::mat4& projection_mat,
+                      const glm::mat4& view_mat) const = 0;
+
+ protected:
+  float red_;
+  float green_;
+  float blue_;
+  float alpha_;
+  std::vector<GLushort> indices_;
+  std::vector<GLfloat> vertices_;
+  std::vector<GLfloat> normals_;
+
+  GLenum render_mode_;
+  GLuint shader_program_;
+  GLuint uniform_color_;
+  GLuint uniform_mvp_mat_;
+  GLuint attrib_vertices_;
+  GLuint attrib_normals_;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_DRAWABLE_OBJECT_H_

app/android/jni/tango-gl/include/tango-gl/frustum.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_FRUSTUM_H_
+#define TANGO_GL_FRUSTUM_H_
+
+#include "tango-gl/line.h"
+
+namespace tango_gl {
+class Frustum : public Line {
+ public:
+  Frustum();
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_FRUSTUM_H_

app/android/jni/tango-gl/include/tango-gl/gesture_camera.h

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_GESTURE_CAMERA_H_
+#define TANGO_GL_GESTURE_CAMERA_H_
+
+#include "tango-gl/camera.h"
+#include "tango-gl/segment.h"
+#include "tango-gl/transform.h"
+#include "tango-gl/util.h"
+
+namespace tango_gl {
+class GestureCamera : public Camera {
+ public:
+  enum CameraType {
+    kFirstPerson = 0,
+    kThirdPersonFollow = 1,
+    kTopDown = 2,
+    kThirdPerson = 3
+  };
+
+  enum TouchEvent {
+    kTouch0Down = 0,
+    kTouch0Up = 1,
+    kTouchMove = 2,
+    kTouch1Down = 5,
+    kTouch1Up = 6,
+    kTouchNone = -1
+  };
+
+  GestureCamera();
+  ~GestureCamera();
+
+  void OnTouchEvent(int touch_count, TouchEvent event, float x0, float y0,
+                    float x1, float y1);
+
+  // Get the ray in opengl world frame given the 2d touch position on screen,
+  // normalized touch_x and normalized touch_y should be the same value get from
+  // OnTouchEvent, x0 and y0, touch_range is the depth of the touch in
+  // camera frame.
+  Segment GetSegmentFromTouch(float normalized_x, float normalized_y,
+                              float touch_range);
+
+  void SetAnchorPosition(const glm::vec3& pos, const glm::quat & rotation);
+
+  // Set camera type, set render camera's parent position and rotation.
+  void SetCameraType(CameraType camera_index);
+
+  CameraType GetCameraType() const { return camera_type_; }
+  float getFOV() const {return field_of_view_ * RADIAN_2_DEGREE;}
+
+ private:
+  void StartCameraToCurrentTransform();
+
+  // Render camera's parent transformation.
+  Transform* cam_parent_transform_;
+
+  CameraType camera_type_;
+
+  glm::vec2 cam_start_angle_;
+  glm::vec2 cam_cur_angle_;
+  glm::quat cam_cur_target_rot_;
+
+  float cam_start_dist_;
+  float cam_cur_dist_;
+
+  float start_touch_dist_;
+  float cur_touch_dist_;
+
+  glm::vec2 touch0_start_position_;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_GESTURE_CAMERA_H_

app/android/jni/tango-gl/include/tango-gl/goal_marker.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ * Distributed under the Project Tango Preview Development Kit (PDK) Agreement.
+ * CONFIDENTIAL. AUTHORIZED USE ONLY. DO NOT REDISTRIBUTE.
+ */
+
+#ifndef TANGO_GL_GOAL_MARKER_H_
+#define TANGO_GL_GOAL_MARKER_H_
+
+#include <tango-gl/mesh.h>
+
+namespace tango_gl {
+class GoalMarker : public Mesh {
+ public:
+  GoalMarker();
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_GOAL_MARKER_H_

app/android/jni/tango-gl/include/tango-gl/grid.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_GRID_H_
+#define TANGO_GL_GRID_H_
+
+#include "tango-gl/line.h"
+
+namespace tango_gl {
+class Grid : public Line {
+ public:
+  Grid(float density = 1.0f, int qx = 50, int qy = 50);
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_GRID_H_

app/android/jni/tango-gl/include/tango-gl/line.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_LINE_H_
+#define TANGO_GL_LINE_H_
+
+#include "tango-gl/drawable_object.h"
+
+namespace tango_gl {
+class Line : public DrawableObject {
+ public:
+  Line(float line_width, GLenum render_mode);
+  void SetLineWidth(const float pixels);
+  void Render(const glm::mat4& projection_mat, const glm::mat4& view_mat) const;
+  void UpdateLineVertices(const std::vector<glm::vec3>& vec_vertices) {
+    vec_vertices_ = vec_vertices;
+  }
+
+ protected:
+  float line_width_;
+  std::vector<glm::vec3> vec_vertices_;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_LINE_H_

app/android/jni/tango-gl/include/tango-gl/mesh.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_MESH_H_
+#define TANGO_GL_MESH_H_
+
+#include "tango-gl/bounding_box.h"
+#include "tango-gl/drawable_object.h"
+#include "tango-gl/segment.h"
+
+namespace tango_gl {
+class Mesh : public DrawableObject {
+ public:
+  Mesh();
+  Mesh(GLenum render_mode);
+  void SetShader();
+  void SetShader(bool is_lighting_on);
+  void SetBoundingBox();
+  void SetLightDirection(const glm::vec3& light_direction);
+  void Render(const glm::mat4& projection_mat, const glm::mat4& view_mat) const;
+  bool IsIntersecting(const Segment& segment);
+
+ protected:
+  BoundingBox* bounding_box_;
+  bool is_lighting_on_;
+  bool is_bounding_box_on_;
+  glm::vec3 light_direction_;
+  GLuint uniform_mv_mat_;
+  GLuint uniform_light_vec_;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_MESH_H_

app/android/jni/tango-gl/include/tango-gl/obj_loader.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_OBJ_LOADER_H
+#define TANGO_GL_OBJ_LOADER_H
+
+#include <vector>
+
+#include "tango-gl/util.h"
+
+namespace tango_gl {
+namespace obj_loader {
+//  Load standard .obj file into vertices, indices or normals vectors,
+//  OBJ file can be exported from 3D tools like 3ds Max or Blender.
+//  A readable file with only vertices should look like
+//  "v 1.00 2.00 3.00
+//   ...
+//   f 1 2 3
+//   f 1 2 3 4
+//   ..."
+//
+//  If exported with normals, file should look like
+//  "v 1.00 2.00 3.00
+//   ...
+//   f 1//1 2//3 3//4
+//   f 1//1 2//3 3//4 4//6
+//   ...
+//   vn 1.00 2.00 3.00
+//   ..."
+//  this can be used with Mesh:
+//
+//  std::vector<GLfloat> vertices;
+//  std::vector<GLushort> indices;
+//  std::vector<GLfloat> normals;
+//  tango_gl::obj_loader::LoadOBJData("/sdcard/model.obj", vertices, indices);
+//  mesh->SetVertices(vertices, indices);
+//  or
+//  tango_gl::obj_loader::LoadOBJData("/sdcard/model.obj", vertices, normals);
+//  mesh->SetVertices(vertices, normals);
+
+bool LoadOBJData(const char* path, std::vector<GLfloat>& vertices,
+                 std::vector<GLushort>& indices);
+
+bool LoadOBJData(const char* path, std::vector<GLfloat>& vertices,
+                 std::vector<GLfloat>& normals);
+}  // namespace obj_loader
+}  // namespace tango_gl
+#endif  // TANGO_GL_OBJ_LOADER

app/android/jni/tango-gl/include/tango-gl/quad.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_QUAD_H_
+#define TANGO_GL_QUAD_H_
+
+#include "tango-gl/drawable_object.h"
+
+namespace tango_gl {
+class Quad : public DrawableObject {
+ public:
+  Quad();
+  Quad(const Quad& other) = delete;
+  Quad& operator=(const Quad&) = delete;
+  ~Quad();
+
+  void Render(const glm::mat4& projection_mat, const glm::mat4& view_mat) const;
+  void SetTextureId(GLuint texture_id);
+
+ private:
+  GLuint vertex_buffer_;
+  GLuint shader_program_;
+  GLuint attrib_vertices_;
+  GLuint texture_coords_;
+  GLuint texture_handle;
+  GLuint uniform_mvp_mat_;
+
+  GLuint texture_id_;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_QUAD_H_

app/android/jni/tango-gl/include/tango-gl/segment.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_SEGMENT_H_
+#define TANGO_GL_SEGMENT_H_
+
+#include "glm/glm.hpp"
+
+namespace tango_gl {
+class Segment {
+ public:
+  Segment() : start(glm::vec3(0, 0, 0)), end(glm::vec3(0, 0, 0)) {}
+  Segment(const glm::vec3& segment_start, const glm::vec3& segment_end)
+      : start(segment_start), end(segment_end) {}
+  Segment(const Segment&) = default;
+  Segment& operator=(const Segment&) = default;
+
+  glm::vec3 start;
+  glm::vec3 end;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_SEGMENT_H_

app/android/jni/tango-gl/include/tango-gl/segment_drawable.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_SEGMENT_DRAWABLE_H_
+#define TANGO_GL_SEGMENT_DRAWABLE_H_
+
+#include "tango-gl/line.h"
+#include "tango-gl/segment.h"
+
+namespace tango_gl {
+class SegmentDrawable : public Line {
+ public:
+  SegmentDrawable();
+  void UpdateSegment(const Segment& segment);
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_SEGMENT_DRAWABLE_H_

app/android/jni/tango-gl/include/tango-gl/shaders.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_SHADERS_H_
+#define TANGO_GL_SHADERS_H_
+
+#include <string>
+
+namespace tango_gl {
+namespace shaders {
+std::string GetBasicVertexShader();
+std::string GetBasicFragmentShader();
+std::string GetColorVertexShader();
+std::string GetVideoOverlayVertexShader();
+std::string GetVideoOverlayFragmentShader();
+std::string GetShadedVertexShader();
+}  // namespace shaders
+}  // namespace tango_gl
+#endif  // TANGO_GL_SHADERS_H_

app/android/jni/tango-gl/include/tango-gl/texture.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_TEXTURE_H_
+#define TANGO_GL_TEXTURE_H_
+
+#include <errno.h>
+#include <png.h>
+
+#include "tango-gl/util.h"
+
+namespace tango_gl {
+class Texture {
+ public:
+  Texture(const char* file_path);
+  Texture(const Texture& other) = delete;
+  Texture& operator=(const Texture&) = delete;
+  ~Texture();
+
+  bool LoadFromPNG(const char* file_path);
+  GLuint GetTextureID() const;
+
+ private:
+  png_uint_32 width_, height_;
+  int bit_depth_, color_type_;
+  char* byte_data_;
+  GLuint texture_id_;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_TEXTURE_H_

app/android/jni/tango-gl/include/tango-gl/trace.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_TRACE_H_
+#define TANGO_GL_TRACE_H_
+
+#include "tango-gl/line.h"
+
+namespace tango_gl {
+class Trace : public Line {
+ public:
+  Trace();
+  void UpdateVertexArray(const glm::vec3& v);
+  void ClearVertexArray();
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_TRACE_H_

app/android/jni/tango-gl/include/tango-gl/transform.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_TRANSFORM_H_
+#define TANGO_GL_TRANSFORM_H_
+
+#include "glm/glm.hpp"
+#include "glm/gtc/quaternion.hpp"
+
+namespace tango_gl {
+class Transform {
+ public:
+  Transform();
+  virtual ~Transform();
+
+  Transform(const Transform& other) = delete;
+  const Transform& operator=(const Transform& rhs) = delete;
+
+  void SetPosition(const glm::vec3& position);
+  glm::vec3 GetPosition() const;
+
+  void SetRotation(const glm::quat& rotation);
+  glm::quat GetRotation() const;
+
+  void SetScale(const glm::vec3& scale);
+  glm::vec3 GetScale() const;
+
+  void Translate(const glm::vec3& translation);
+
+  void SetTransformationMatrix(const glm::mat4& transform_mat);
+  glm::mat4 GetTransformationMatrix() const;
+
+  void SetParent(Transform* transform);
+
+  const Transform* GetParent() const ;
+  Transform* GetParent() ;
+
+ private:
+  Transform* parent_;
+
+  glm::vec3 position_;
+  glm::quat rotation_;
+  glm::vec3 scale_;
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_TRANSFORM_H_

app/android/jni/tango-gl/include/tango-gl/triangle.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_TRIANGLE_H_
+#define TANGO_GL_TRIANGLE_H_
+
+#include "tango-gl/mesh.h"
+
+namespace tango_gl {
+class Triangle : public Mesh {
+ public:
+  Triangle();
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_TRIANGLE_H_

app/android/jni/tango-gl/include/tango-gl/util.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_GL_UTIL_H_
+#define TANGO_GL_GL_UTIL_H_
+#define GLM_FORCE_RADIANS
+
+#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
+
+#include <stdlib.h>
+#include <jni.h>
+#include <android/log.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#include "glm/glm.hpp"
+#include "glm/gtc/matrix_transform.hpp"
+#include "glm/gtc/quaternion.hpp"
+#include "glm/gtc/type_ptr.hpp"
+#include "glm/gtx/matrix_decompose.hpp"
+
+#define LOG_TAG "rtabmap"
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG,__VA_ARGS__)
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
+#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,LOG_TAG,__VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
+
+#ifndef M_PI
+#define M_PI 3.1415926f
+#endif
+
+#define RADIAN_2_DEGREE 57.2957795f
+#define DEGREE_2_RADIANS 0.0174532925f
+
+namespace tango_gl {
+namespace util {
+  void CheckGlError(const char* operation);
+
+  GLuint CreateProgram(const char* vertex_source,
+                       const char* fragment_source);
+
+  void DecomposeMatrix(const glm::mat4& transform_mat,
+                       glm::vec3& translation,
+                       glm::quat& rotation,
+                       glm::vec3& scale);
+
+  // Get a 3x1 column from the upper 3x4 of a transformation matrix. Columns
+  // 0, 1, 2 are the rotation/scale portion, and column 3 is the translation.
+  glm::vec3 GetColumnFromMatrix(const glm::mat4& mat, const int col);
+
+  // Get the translation component of a transformation matrix.
+  glm::vec3 GetTranslationFromMatrix(const glm::mat4& mat);
+
+  float Clamp(float value, float min, float max);
+  void PrintMatrix(const glm::mat4& matrix);
+  void PrintVector(const glm::vec3& vector);
+  void PrintQuaternion(const glm::quat& quat);
+
+  glm::vec3 LerpVector(const glm::vec3& x, const glm::vec3& y, float a);
+  float DistanceSquared(const glm::vec3& v1, const glm::vec3& v2);
+
+  bool SegmentAABBIntersect(const glm::vec3& aabb_min, const glm::vec3& aabb_max,
+                        const glm::vec3& start, const glm::vec3& end);
+
+  glm::vec3 ApplyTransform(const glm::mat4& mat, const glm::vec3& vec);
+}  // namespace util
+}  // namespace tango_gl
+#endif  // TANGO_GL_RENDERER_GL_UTIL

app/android/jni/tango-gl/include/tango-gl/video_overlay.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TANGO_GL_RENDERER_VIDEO_OVERLAY_H_
+#define TANGO_GL_RENDERER_VIDEO_OVERLAY_H_
+
+#include "tango-gl/drawable_object.h"
+
+namespace tango_gl {
+class VideoOverlay : public DrawableObject {
+ public:
+  VideoOverlay();
+  void Render(const glm::mat4& projection_mat, const glm::mat4& view_mat) const;
+  GLuint GetTextureId() const { return texture_id_; }
+  void SetTextureId(GLuint texture_id) { texture_id_ = texture_id; }
+
+ private:
+  // This id is populated on construction, and is passed to the tango service.
+  GLuint texture_id_;
+
+  GLuint attrib_texture_coords_;
+  GLuint uniform_texture_;
+  GLuint vertex_buffers_[3];
+};
+}  // namespace tango_gl
+#endif  // TANGO_GL_RENDERER_VIDEO_OVERLAY_H_

app/android/jni/tango-gl/line.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/line.h"
+
+namespace tango_gl {
+Line::Line(float line_width, GLenum render_mode) {
+  line_width_ = line_width;
+  render_mode_ = render_mode;
+}
+void Line::SetLineWidth(const float pixels) { line_width_ = pixels; }
+void Line::Render(const glm::mat4& projection_mat,
+                  const glm::mat4& view_mat) const {
+  glUseProgram(shader_program_);
+  glLineWidth(line_width_);
+  glm::mat4 model_mat = GetTransformationMatrix();
+  glm::mat4 mvp_mat = projection_mat * view_mat * model_mat;
+  glUniformMatrix4fv(uniform_mvp_mat_, 1, GL_FALSE, glm::value_ptr(mvp_mat));
+
+  glUniform4f(uniform_color_, red_, green_, blue_, alpha_);
+
+  glEnableVertexAttribArray(attrib_vertices_);
+  glVertexAttribPointer(attrib_vertices_, 3, GL_FLOAT, GL_FALSE,
+                        sizeof(glm::vec3), &vec_vertices_[0]);
+  glDrawArrays(render_mode_, 0, vec_vertices_.size());
+
+  glDisableVertexAttribArray(attrib_vertices_);
+  glUseProgram(0);
+}
+
+}  // namespace tango_gl

app/android/jni/tango-gl/mesh.cpp

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/mesh.h"
+#include "tango-gl/shaders.h"
+
+namespace tango_gl {
+Mesh::Mesh() {
+  render_mode_ = GL_TRIANGLES;
+}
+Mesh::Mesh(GLenum render_mode) {
+  render_mode_ = render_mode;
+}
+
+void Mesh::SetShader() {
+  DrawableObject::SetShader();
+  // Default mode set to no lighting.
+  is_lighting_on_ = false;
+  // Default mode set to without bounding box detection.
+  is_bounding_box_on_ = false;
+}
+
+void Mesh::SetShader(bool is_lighting_on) {
+  if (is_lighting_on) {
+    shader_program_ =
+        util::CreateProgram(shaders::GetShadedVertexShader().c_str(),
+                            shaders::GetBasicFragmentShader().c_str());
+    if (!shader_program_) {
+      LOGE("Could not create program.");
+    }
+    uniform_mvp_mat_ = glGetUniformLocation(shader_program_, "mvp");
+    uniform_mv_mat_ = glGetUniformLocation(shader_program_, "mv");
+    uniform_light_vec_ = glGetUniformLocation(shader_program_, "lightVec");
+    uniform_color_ = glGetUniformLocation(shader_program_, "color");
+
+    attrib_vertices_ = glGetAttribLocation(shader_program_, "vertex");
+    attrib_normals_ = glGetAttribLocation(shader_program_, "normal");
+    is_lighting_on_ = true;
+    // Set a defualt direction for directional light.
+    light_direction_ = glm::vec3(-1.0f, -3.0f, -1.0f);
+    light_direction_ = glm::normalize(light_direction_);
+  } else {
+    SetShader();
+  }
+}
+
+void Mesh::SetBoundingBox(){
+  // Traverse all the vertices to define an axis-aligned
+  // bounding box for this mesh, needs to be called after SetVertices().
+  if(vertices_.size()==0){
+    LOGE("Please set up vertices first!");
+    return;
+  }
+  is_bounding_box_on_ = true;
+  bounding_box_ = new BoundingBox(vertices_);
+}
+
+void Mesh::SetLightDirection(const glm::vec3& light_direction) {
+  light_direction_ = light_direction;
+}
+
+bool Mesh::IsIntersecting(const Segment& segment) {
+  // If there is no bounding box defined based on all vertices,
+  // we can not calculate intersection.
+  if (!is_bounding_box_on_) {
+    LOGE("Mesh::IsIntersecting, bounding box is not available.");
+    return false;
+  }
+  return bounding_box_->IsIntersecting(segment, GetRotation(),
+                                       GetTransformationMatrix());
+}
+
+void Mesh::Render(const glm::mat4& projection_mat,
+                  const glm::mat4& view_mat) const {
+  glUseProgram(shader_program_);
+  glm::mat4 model_mat = GetTransformationMatrix();
+  glm::mat4 mv_mat = view_mat * model_mat;
+  glm::mat4 mvp_mat = projection_mat * mv_mat;
+  glUniformMatrix4fv(uniform_mvp_mat_, 1, GL_FALSE, glm::value_ptr(mvp_mat));
+  glUniform4f(uniform_color_, red_, green_, blue_, alpha_);
+
+  if (is_lighting_on_) {
+    glUniformMatrix4fv(uniform_mv_mat_, 1, GL_FALSE, glm::value_ptr(mv_mat));
+
+    glEnableVertexAttribArray(attrib_normals_);
+    glVertexAttribPointer(attrib_normals_, 3, GL_FLOAT, GL_FALSE,
+                          3 * sizeof(GLfloat), &normals_[0]);
+    glm::vec3 light_direction = glm::mat3(view_mat) * light_direction_;
+    glUniform3fv(uniform_light_vec_, 1, glm::value_ptr(light_direction));
+  }
+
+  glEnableVertexAttribArray(attrib_vertices_);
+
+  if (!indices_.empty()) {
+    glVertexAttribPointer(attrib_vertices_, 3, GL_FLOAT, GL_FALSE,
+                          3 * sizeof(GLfloat), vertices_.data());
+    glDrawElements(render_mode_, indices_.size(), GL_UNSIGNED_SHORT,
+                   indices_.data());
+  } else {
+    glVertexAttribPointer(attrib_vertices_, 3, GL_FLOAT, GL_FALSE,
+                          3 * sizeof(GLfloat), &vertices_[0]);
+    glDrawArrays(render_mode_, 0, vertices_.size() / 3);
+  }
+
+  glDisableVertexAttribArray(attrib_vertices_);
+  if (is_lighting_on_) {
+    glDisableVertexAttribArray(attrib_normals_);
+  }
+  glUseProgram(0);
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/obj_loader.cpp

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <string>
+
+#include "tango-gl/obj_loader.h"
+
+namespace tango_gl {
+bool obj_loader::LoadOBJData(const char* path, std::vector<GLfloat>& vertices,
+                             std::vector<GLushort>& indices) {
+  FILE *file = fopen(path, "r");
+  if (file == NULL) {
+    LOGE("Failed to open file: %s", path);
+    return false;
+  }
+
+  while (1) {
+    char lineHeader[128];
+    int res = fscanf(file, "%s", lineHeader);
+    if (res == EOF) break;
+    if (strcmp(lineHeader, "v") == 0) {
+      GLfloat vertex[3];
+      int matches =
+          fscanf(file, "%f %f %f\n", &vertex[0], &vertex[1], &vertex[2]);
+      if (matches != 3) {
+        LOGE("Format of 'v float float float' required for each vertice line");
+        return false;
+      }
+      vertices.push_back(vertex[0]);
+      vertices.push_back(vertex[1]);
+      vertices.push_back(vertex[2]);
+    } else if (strcmp(lineHeader, "f") == 0) {
+      GLushort vertexIndex[3];
+      int matches = fscanf(file, "%hu %hu %hu\n", &vertexIndex[0],
+                           &vertexIndex[1], &vertexIndex[2]);
+      if (matches != 3) {
+        LOGE("Format of 'f int int int' required for each face line");
+        return false;
+      }
+      indices.push_back(vertexIndex[0] - 1);
+      indices.push_back(vertexIndex[1] - 1);
+      indices.push_back(vertexIndex[2] - 1);
+    }
+    else {
+      char comments_buffer[1000];
+      fgets(comments_buffer, 1000, file);
+    }
+  }
+  fclose(file);
+  return true;
+}
+
+bool obj_loader::LoadOBJData(const char* path, std::vector<GLfloat>& vertices,
+                             std::vector<GLfloat>& normals) {
+  std::vector<unsigned int> vertexIndices, normalIndices;
+  std::vector<GLfloat> temp_vertices, temp_normals;
+
+  FILE* file = fopen(path, "r");
+  if (file == NULL) {
+    LOGE("Failed to open file: %s", path);
+    return false;
+  }
+
+  while (1) {
+    char lineHeader[128];
+    int res = fscanf(file, "%s", lineHeader);
+    if (res == EOF) break;
+    if (strcmp(lineHeader, "v") == 0) {
+      GLfloat vertex[3];
+      int matches =
+          fscanf(file, "%f %f %f\n", &vertex[0], &vertex[1], &vertex[2]);
+      if (matches != 3) {
+        LOGE("Format of 'v float float float' required for each vertice line");
+        return false;
+      }
+      temp_vertices.push_back(vertex[0]);
+      temp_vertices.push_back(vertex[1]);
+      temp_vertices.push_back(vertex[2]);
+    } else if (strcmp(lineHeader, "vn") == 0) {
+      GLfloat normal[3];
+      int matches =
+          fscanf(file, "%f %f %f\n", &normal[0], &normal[1], &normal[2]);
+      if (matches != 3) {
+        LOGE("Format of 'vn float float float' required for each normal line");
+        return false;
+      }
+      temp_normals.push_back(normal[0]);
+      temp_normals.push_back(normal[1]);
+      temp_normals.push_back(normal[2]);
+    } else if (strcmp(lineHeader, "f") == 0) {
+      GLushort vertexIndex[4];
+      GLushort normalIndex[4];
+      int matches = fscanf(file, "%hu//%hu %hu//%hu %hu//%hu %hu//%hu\n",
+                           &vertexIndex[0], &normalIndex[0], &vertexIndex[1], &normalIndex[1],
+                           &vertexIndex[2], &normalIndex[2], &vertexIndex[3], &normalIndex[3]);
+
+      // .obj file is 1-indexed, so subtract 1 from all indices.
+      if (matches == 6) {
+        // If triangles provided.
+        vertexIndices.push_back(vertexIndex[0] - 1);
+        vertexIndices.push_back(vertexIndex[1] - 1);
+        vertexIndices.push_back(vertexIndex[2] - 1);
+        normalIndices.push_back(normalIndex[0] - 1);
+        normalIndices.push_back(normalIndex[1] - 1);
+        normalIndices.push_back(normalIndex[2] - 1);
+      } else if(matches == 8) {
+        // If quads provided.
+        vertexIndices.push_back(vertexIndex[0] - 1);
+        vertexIndices.push_back(vertexIndex[1] - 1);
+        vertexIndices.push_back(vertexIndex[2] - 1);
+        vertexIndices.push_back(vertexIndex[0] - 1);
+        vertexIndices.push_back(vertexIndex[2] - 1);
+        vertexIndices.push_back(vertexIndex[3] - 1);
+        normalIndices.push_back(normalIndex[0] - 1);
+        normalIndices.push_back(normalIndex[1] - 1);
+        normalIndices.push_back(normalIndex[2] - 1);
+        normalIndices.push_back(normalIndex[0] - 1);
+        normalIndices.push_back(normalIndex[2] - 1);
+        normalIndices.push_back(normalIndex[3] - 1);
+      } else {
+        LOGE("Format of 'f int//int int//int int//int' required for each face");
+        return false;
+      }
+    } else {
+      char comments_buffer[1000];
+      fgets(comments_buffer, 1000, file);
+    }
+  }
+
+  for (unsigned int i = 0; i < vertexIndices.size(); i++) {
+    unsigned int vertexIndex = vertexIndices[i];
+    unsigned int normalIndex = normalIndices[i];
+
+    vertices.push_back(temp_vertices[vertexIndex * 3]);
+    vertices.push_back(temp_vertices[vertexIndex * 3 + 1]);
+    vertices.push_back(temp_vertices[vertexIndex * 3 + 2]);
+    normals.push_back(temp_normals[normalIndex * 3]);
+    normals.push_back(temp_normals[normalIndex * 3 + 1]);
+    normals.push_back(temp_normals[normalIndex * 3 + 2]);
+  }
+  fclose(file);
+  return true;
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/quad.cpp

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/quad.h"
+#include "tango-gl/util.h"
+
+namespace tango_gl {
+
+static const char kVertexShader[] =
+    "attribute vec4 vertex;\n"
+    "attribute vec2 inputTextureCoordinate;\n"
+    "varying vec2 textureCoordinate;\n"
+    "uniform mat4 mvp;\n"
+    "void main() {\n"
+    "  gl_Position = mvp*vertex;\n"
+    "  textureCoordinate = inputTextureCoordinate.xy;\n"
+    "}\n";
+
+static const char kFragmentShader[] =
+    "varying vec2 textureCoordinate;\n"
+    "uniform sampler2D inputTexture;\n"
+    "void main() {\n"
+    "  gl_FragColor = texture2D(inputTexture, textureCoordinate);\n"
+    "}\n";
+
+static const float vertices[] = {-0.5f, -0.5f, 0.5f, -0.5f,
+                                 -0.5f, 0.5f,  0.5f, 0.5f};
+
+static const GLfloat texture_coords[] = {0.0f, 1.0f, 1.0f, 1.0f,
+                                         0.0f, 0.0f, 1.0f, 0.0f, };
+
+Quad::Quad() {
+  shader_program_ = util::CreateProgram(kVertexShader, kFragmentShader);
+  if (!shader_program_) {
+    LOGE("Could not create program.");
+  }
+  uniform_mvp_mat_ = glGetUniformLocation(shader_program_, "mvp");
+  attrib_vertices_ = glGetAttribLocation(shader_program_, "vertex");
+  texture_coords_ =
+      glGetAttribLocation(shader_program_, "inputTextureCoordinate");
+  texture_handle = glGetUniformLocation(shader_program_, "inputTexture");
+  glGenBuffers(1, &vertex_buffer_);
+}
+
+Quad::~Quad() { glDeleteShader(shader_program_); }
+
+void Quat::SetTextureId(GLuint texture_id) { texture_id_ = texture_id; }
+
+void Quad::Render(const glm::mat4& projection_mat,
+                  const glm::mat4& view_mat) const {
+  glEnable(GL_CULL_FACE);
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  glUseProgram(shader_program_);
+
+  glBindTexture(GL_TEXTURE_2D, texture_id_);
+  glUniform1i(texture_handle, 0);
+
+  // Calculate MVP matrix and pass it to shader.
+  glm::mat4 model_mat = GetTransformationMatrix();
+  glm::mat4 mvp_mat = projection_mat * view_mat * model_mat;
+  glUniformMatrix4fv(uniform_mvp_mat_, 1, GL_FALSE, glm::value_ptr(mvp_mat));
+
+  // Vertice binding
+  glEnableVertexAttribArray(attrib_vertices_);
+  glVertexAttribPointer(attrib_vertices_, 2, GL_FLOAT, GL_FALSE, 0, vertices);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+  glEnableVertexAttribArray(texture_coords_);
+  glVertexAttribPointer(texture_coords_, 2, GL_FLOAT, GL_FALSE, 0,
+                        texture_coords);
+
+  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+  glUseProgram(0);
+  glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+}  // namespace tango_gl

app/android/jni/tango-gl/segment_drawable.cpp

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/segment_drawable.h"
+
+namespace tango_gl {
+SegmentDrawable::SegmentDrawable() : tango_gl::Line(5.0f, GL_LINES) {
+  SetShader();
+  vec_vertices_.push_back(glm::vec3(0, 0, 0));
+  vec_vertices_.push_back(glm::vec3(1.f, 1.f, 1.f));
+}
+void SegmentDrawable::UpdateSegment(const Segment& segment) {
+  vec_vertices_[0] = segment.start;
+  vec_vertices_[1] = segment.end;
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/shaders.cpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "tango-gl/shaders.h"
+
+namespace tango_gl {
+namespace shaders {
+std::string GetBasicVertexShader() {
+  return "precision mediump float;\n"
+         "precision mediump int;\n"
+         "attribute vec4 vertex;\n"
+         "uniform mat4 mvp;\n"
+         "uniform vec4 color;\n"
+         "varying vec4 v_color;\n"
+         "void main() {\n"
+         "  gl_Position = mvp*vertex;\n"
+         "  v_color = color;\n"
+         "}\n";
+}
+
+std::string GetBasicFragmentShader() {
+  return "precision mediump float;\n"
+         "varying vec4 v_color;\n"
+         "void main() {\n"
+         "  gl_FragColor = v_color;\n"
+         "}\n";
+}
+
+std::string GetColorVertexShader() {
+  return "precision mediump float;\n"
+         "precision mediump int;\n"
+         "attribute vec4 vertex;\n"
+         "attribute vec4 color;\n"
+         "uniform mat4 mvp;\n"
+         "varying vec4 v_color;\n"
+         "void main() {\n"
+         "  gl_Position = mvp*vertex;\n"
+         "  v_color = color;\n"
+         "}\n";
+}
+
+std::string GetVideoOverlayVertexShader() {
+  return "precision highp float;\n"
+         "precision highp int;\n"
+         "attribute vec4 vertex;\n"
+         "attribute vec2 textureCoords;\n"
+         "varying vec2 f_textureCoords;\n"
+         "uniform mat4 mvp;\n"
+         "void main() {\n"
+         "  f_textureCoords = textureCoords;\n"
+         "  gl_Position = mvp * vertex;\n"
+         "}\n";
+}
+
+std::string GetVideoOverlayFragmentShader() {
+  return "#extension GL_OES_EGL_image_external : require\n"
+         "precision highp float;\n"
+         "precision highp int;\n"
+         "uniform samplerExternalOES texture;\n"
+         "varying vec2 f_textureCoords;\n"
+         "void main() {\n"
+         "  gl_FragColor = texture2D(texture, f_textureCoords);\n"
+         "}\n";
+}
+
+std::string GetShadedVertexShader() {
+  return "attribute vec4 vertex;\n"
+         "attribute vec3 normal;\n"
+         "uniform mat4 mvp;\n"
+         "uniform mat4 mv;\n"
+         "uniform vec4 color;\n"
+         "uniform vec3 lightVec;\n"
+         "varying vec4 v_color;\n"
+         "void main() {\n"
+         "  vec3 mvNormal = vec3(mv * vec4(normal, 0.0));\n"
+         "  float diffuse = max(-dot(mvNormal, lightVec), 0.0);\n"
+         "  v_color.a = color.a;\n"
+         "  v_color.xyz = color.xyz * diffuse + color.xyz * 0.3;\n"
+         "  gl_Position = mvp*vertex;\n"
+         "}\n";
+}
+}  // namespace shaders
+}  // namespace tango_gl

app/android/jni/tango-gl/texture.cpp

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "tango-gl/texture.h"
+#include "tango-gl/util.h"
+
+namespace tango_gl {
+
+static const int kMaxExponentiation = 12;
+
+static int RoundUpPowerOfTwo(int w) {
+  int start = 2;
+  for (int i = 0; i <= kMaxExponentiation; ++i) {
+    if (w < start) {
+      w = start;
+      break;
+    } else {
+      start = start << 1;
+    }
+  }
+  return w;
+}
+
+Texture::Texture(const char* file_path) {
+  if (!LoadFromPNG(file_path)) {
+    LOGE("Texture initialing error");
+  }
+}
+
+bool Texture::LoadFromPNG(const char* file_path) {
+  FILE* file = fopen(file_path, "rb");
+
+  if (file == NULL) {
+    LOGE("fp not loaded: %s", strerror(errno));
+    return false;
+  }
+
+  fseek(file, 8, SEEK_CUR);
+
+  png_structp png_ptr =
+      png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+  png_infop info_ptr = png_create_info_struct(png_ptr);
+
+  png_init_io(png_ptr, file);
+  png_set_sig_bytes(png_ptr, 8);
+  png_read_info(png_ptr, info_ptr);
+  png_get_IHDR(png_ptr, info_ptr, &width_, &height_, &bit_depth_, &color_type_,
+               NULL, NULL, NULL);
+
+  width_ = RoundUpPowerOfTwo(width_);
+  height_ = RoundUpPowerOfTwo(height_);
+  int row = width_ * (color_type_ == PNG_COLOR_TYPE_RGBA ? 4 : 3);
+  byte_data_ = new char[row * height_];
+
+  png_bytep* row_pointers = new png_bytep[height_];
+  for (uint i = 0; i < height_; ++i) {
+    row_pointers[i] = (png_bytep)(byte_data_ + i * row);
+  }
+  png_read_image(png_ptr, row_pointers);
+  png_destroy_read_struct(&png_ptr, &info_ptr, 0);
+
+  glGenTextures(1, &texture_id_);
+  glBindTexture(GL_TEXTURE_2D, texture_id_);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  util::CheckGlError("glBindTexture");
+  if (color_type_ == PNG_COLOR_TYPE_RGBA) {
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width_, height_, 0, GL_RGBA,
+                 GL_UNSIGNED_BYTE, byte_data_);
+  } else {
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width_, height_, 0, GL_RGB,
+                 GL_UNSIGNED_BYTE, byte_data_);
+  }
+  util::CheckGlError("glTexImage2D");
+  glBindTexture(GL_TEXTURE_2D, 0);
+
+  fclose(file);
+  delete[] row_pointers;
+  delete[] byte_data_;
+
+  return true;
+}
+
+GLuint Texture::GetTextureID() const { return texture_id_; }
+
+Texture::~Texture() {
+  if (byte_data_ != NULL) {
+    delete[] byte_data_;
+  }
+  byte_data_ = NULL;
+}
+
+}  // namespace tango_gl

app/android/jni/tango-gl/trace.cpp

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/trace.h"
+
+namespace tango_gl {
+
+static const int kMaxTraceLength = 5000;
+static const float kDistanceCheck = 0.05f;
+
+Trace::Trace() : Line(3.0f, GL_LINE_STRIP) { SetShader(); }
+
+void Trace::UpdateVertexArray(const glm::vec3& v) {
+  if (vec_vertices_.size() == 0) {
+    vec_vertices_.push_back(v);
+  } else {
+    float dist = glm::distance(vec_vertices_[vec_vertices_.size() - 1], v);
+    if (dist >= kDistanceCheck) {
+      vec_vertices_.push_back(v);
+    }
+  }
+}
+
+void Trace::ClearVertexArray() { vec_vertices_.clear(); }
+}  // namespace tango_gl

app/android/jni/tango-gl/transform.cpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/transform.h"
+#include "tango-gl/util.h"
+
+#define nullptr 0
+
+namespace tango_gl {
+
+Transform::Transform()
+  : parent_(nullptr),
+    position_(0.0f, 0.0f, 0.0f),
+    rotation_(1.0f, 0.0f, 0.0f, 0.0f),
+    scale_(1.0f, 1.0f, 1.0f) {
+}
+
+Transform::~Transform() {
+  // Objects are not responsible for deleting their parents.
+}
+
+void Transform::SetPosition(const glm::vec3& position) {
+  position_ = position;
+}
+
+glm::vec3 Transform::GetPosition() const {
+  return position_;
+}
+
+void Transform::SetRotation(const glm::quat& rotation) {
+  rotation_ = rotation;
+}
+
+glm::quat Transform::GetRotation() const {
+  return rotation_;
+}
+
+void Transform::SetScale(const glm::vec3& scale) {
+  scale_ = scale;
+}
+
+glm::vec3 Transform::GetScale() const {
+  return scale_;
+}
+
+void Transform::Translate(const glm::vec3& translation) {
+  position_ += translation;
+}
+
+void Transform::SetTransformationMatrix(const glm::mat4& transform_mat) {
+  util::DecomposeMatrix(transform_mat, position_, rotation_, scale_);
+}
+
+glm::mat4 Transform::GetTransformationMatrix() const {
+  glm::mat4 trans_mat = glm::scale(glm::mat4_cast(rotation_), scale_);
+  trans_mat[3][0] = position_.x;
+  trans_mat[3][1] = position_.y;
+  trans_mat[3][2] = position_.z;
+  glm::mat4 parent_mat = glm::mat4(1.0f);
+  if (parent_ != NULL) {
+    parent_mat = parent_->GetTransformationMatrix();
+    trans_mat = parent_mat * trans_mat;
+  }
+  return  trans_mat;
+}
+
+void Transform::SetParent(Transform* transform) {
+  parent_ = transform;
+}
+
+const Transform* Transform::GetParent() const {
+  return parent_;
+}
+
+Transform* Transform::GetParent() {
+  return parent_;
+}
+
+}  // namespace tango_gl

app/android/jni/tango-gl/triangle.cpp

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/triangle.h"
+
+namespace tango_gl {
+
+static const GLfloat const_vertices[]
+  = {-0.15f, 0.0f, 0.0f, 0.15f, 0.0f, 0.0f, 0.0f, 0.0f, -0.2f};
+
+static const GLushort const_indices[] = {0, 1, 2};
+
+Triangle::Triangle() {
+  SetShader();
+  std::vector<GLfloat> vertices(
+      const_vertices,
+      const_vertices + sizeof(const_vertices) / sizeof(GLfloat));
+  std::vector<GLushort> indices(
+      const_indices, const_indices + sizeof(const_indices) / sizeof(GLushort));
+  SetVertices(vertices, indices);
+}
+}  // namespace tango_gl

app/android/jni/tango-gl/util.cpp

@@ -0,0 +1,220 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/util.h"
+#include <rtabmap/utilite/ULogger.h>
+
+namespace tango_gl {
+
+void util::CheckGlError(const char* operation) {
+  for (GLint error = glGetError(); error; error = glGetError()) {
+    LOGE("after %s() glError (0x%x)\n", operation, error);
+  }
+}
+
+// Convenience function used in CreateProgram below.
+static GLuint LoadShader(GLenum shader_type, const char* shader_source) {
+  GLuint shader = glCreateShader(shader_type);
+  if (shader) {
+    glShaderSource(shader, 1, &shader_source, NULL);
+    glCompileShader(shader);
+    GLint compiled = 0;
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+    if (!compiled) {
+      GLint info_len = 0;
+      glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_len);
+      if (info_len) {
+        char* buf = (char*) malloc(info_len);
+        if (buf) {
+          glGetShaderInfoLog(shader, info_len, NULL, buf);
+          LOGE("Could not compile shader %d:\n%s\n", shader_type, buf);
+          free(buf);
+        }
+        glDeleteShader(shader);
+        shader = 0;
+      }
+    }
+  }
+  return shader;
+}
+
+GLuint util::CreateProgram(const char* vertex_source,
+                             const char* fragment_source) {
+  GLuint vertexShader = LoadShader(GL_VERTEX_SHADER, vertex_source);
+  if (!vertexShader) {
+    return 0;
+  }
+
+  GLuint fragment_shader = LoadShader(GL_FRAGMENT_SHADER, fragment_source);
+  if (!fragment_shader) {
+    return 0;
+  }
+
+  GLuint program = glCreateProgram();
+  if (program) {
+    glAttachShader(program, vertexShader);
+    CheckGlError("glAttachShader");
+    glAttachShader(program, fragment_shader);
+    CheckGlError("glAttachShader");
+    glLinkProgram(program);
+    GLint link_status = GL_FALSE;
+    glGetProgramiv(program, GL_LINK_STATUS, &link_status);
+    if (link_status != GL_TRUE) {
+      GLint buf_length = 0;
+      glGetProgramiv(program, GL_INFO_LOG_LENGTH, &buf_length);
+      if (buf_length) {
+        char* buf = (char*) malloc(buf_length);
+        if (buf) {
+          glGetProgramInfoLog(program, buf_length, NULL, buf);
+          LOGE("Could not link program:\n%s\n", buf);
+          free(buf);
+        }
+      }
+      glDeleteProgram(program);
+      program = 0;
+    }
+  }
+  CheckGlError("CreateProgram");
+  return program;
+}
+
+void util::DecomposeMatrix (const glm::mat4& transform_mat,
+                              glm::vec3& translation,
+                              glm::quat& rotation,
+                              glm::vec3& scale) {
+  float scale_x = glm::length( glm::vec3( transform_mat[0][0], transform_mat[1][0], transform_mat[2][0] ) );
+  float scale_y = glm::length( glm::vec3( transform_mat[0][1], transform_mat[1][1], transform_mat[2][1] ) );
+  float scale_z = glm::length( glm::vec3( transform_mat[0][2], transform_mat[1][2], transform_mat[2][2] ) );
+
+
+  float determinant = glm::determinant( transform_mat );
+  if( determinant < 0.0 )
+    scale_x = -scale_x;
+
+  translation.x = transform_mat[3][0];
+  translation.y = transform_mat[3][1];
+  translation.z = transform_mat[3][2];
+
+  float inverse_scale_x = 1.0 / scale_x;
+  float inverse_scale_y = 1.0 / scale_y;
+  float inverse_scale_z = 1.0 / scale_z;
+
+  glm::mat4 transform_unscaled = transform_mat;
+
+  transform_unscaled[0][0] *= inverse_scale_x;
+  transform_unscaled[1][0] *= inverse_scale_x;
+  transform_unscaled[2][0] *= inverse_scale_x;
+
+  transform_unscaled[0][1] *= inverse_scale_y;
+  transform_unscaled[1][1] *= inverse_scale_y;
+  transform_unscaled[2][1] *= inverse_scale_y;
+
+  transform_unscaled[0][2] *= inverse_scale_z;
+  transform_unscaled[1][2] *= inverse_scale_z;
+  transform_unscaled[2][2] *= inverse_scale_z;
+
+  rotation = glm::quat_cast( transform_mat );
+
+  scale.x = scale_x;
+  scale.y = scale_y;
+  scale.z = scale_z;
+}
+
+glm::vec3 util::GetColumnFromMatrix(const glm::mat4& mat, const int col) {
+  return glm::vec3(mat[col][0], mat[col][1], mat[col][2]);
+}
+
+glm::vec3 util::GetTranslationFromMatrix(const glm::mat4& mat) {
+  return glm::vec3(mat[3][0], mat[3][1], mat[3][2]);
+}
+
+float util::Clamp(float value, float min, float max) {
+  return value < min ? min : (value > max ? max : value);
+}
+
+// Print out a column major matrix.
+void util::PrintMatrix(const glm::mat4& matrix) {
+  int i;
+  for (i = 0; i < 4; i++) {
+    LOGI("[ %f, %f, %f, %f ]", matrix[0][i], matrix[1][i], matrix[2][i],
+         matrix[3][i]);
+  }
+  LOGI(" ");
+}
+
+void util::PrintVector(const glm::vec3& vector) {
+  LOGI("[ %f, %f, %f ]", vector[0], vector[1], vector[2]);
+  LOGI(" ");
+}
+
+void util::PrintQuaternion(const glm::quat& quat) {
+  LOGI("[ %f, %f, %f, %f ]", quat[0], quat[1], quat[2], quat[3]);
+  LOGI(" ");
+}
+
+glm::vec3 util::LerpVector(const glm::vec3& x, const glm::vec3& y, float a) {
+  return x * (1.0f - a) + y * a;
+}
+
+float util::DistanceSquared(const glm::vec3& v1, const glm::vec3& v2) {
+  glm::vec3 delta = v2 - v1;
+  return glm::dot(delta, delta);
+}
+
+bool util::SegmentAABBIntersect(const glm::vec3& aabb_min,
+                            const glm::vec3& aabb_max,
+                            const glm::vec3& start,
+                            const glm::vec3& end) {
+  float tmin, tmax, tymin, tymax, tzmin, tzmax;
+  glm::vec3 direction = end - start;
+  if (direction.x >= 0) {
+    tmin = (aabb_min.x - start.x) / direction.x;
+    tmax = (aabb_max.x - start.x) / direction.x;
+  } else {
+    tmin = (aabb_max.x - start.x) / direction.x;
+    tmax = (aabb_min.x - start.x) / direction.x;
+  }
+  if (direction.y >= 0) {
+    tymin = (aabb_min.y - start.y) / direction.y;
+    tymax = (aabb_max.y - start.y) / direction.y;
+  } else {
+    tymin = (aabb_max.y - start.y) / direction.y;
+    tymax = (aabb_min.y - start.y) / direction.y;
+  }
+  if ((tmin > tymax) || (tymin > tmax)) return false;
+
+  if (tymin > tmin) tmin = tymin;
+  if (tymax < tmax) tmax = tymax;
+  if (direction.z >= 0) {
+    tzmin = (aabb_min.z - start.z) / direction.z;
+    tzmax = (aabb_max.z - start.z) / direction.z;
+  } else {
+    tzmin = (aabb_max.z - start.z) / direction.z;
+    tzmax = (aabb_min.z - start.z) / direction.z;
+  }
+  if ((tmin > tzmax) || (tzmin > tmax)) return false;
+
+  if (tzmin > tmin) tmin = tzmin;
+  if (tzmax < tmax) tmax = tzmax;
+  // Use the full length of the segment.
+  return ((tmin < 1.0f) && (tmax > 0));
+}
+
+glm::vec3 util::ApplyTransform(const glm::mat4& mat, const glm::vec3& vec) {
+  return glm::vec3(mat * glm::vec4(vec, 1.0f));
+}
+
+}  // namespace tango_gl

app/android/jni/tango-gl/video_overlay.cpp

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tango-gl/video_overlay.h"
+#include "tango-gl/shaders.h"
+
+namespace tango_gl {
+
+static const GLfloat kVertices[] =
+  {-1.0,  1.0, 0.0,
+   -1.0, -1.0, 0.0,
+    1.0,  1.0, 0.0,
+    1.0, -1.0, 0.0};
+
+static const GLushort kIndices[] =
+  {0, 1, 2, 2, 1, 3};
+
+static const GLfloat kTextureCoords[] =
+  {0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0};
+
+VideoOverlay::VideoOverlay() {
+  glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
+  shader_program_ =
+      util::CreateProgram(shaders::GetVideoOverlayVertexShader().c_str(),
+                          shaders::GetVideoOverlayFragmentShader().c_str());
+  if (!shader_program_) {
+    LOGE("Could not create program.");
+  }
+
+  glGenTextures(1, &texture_id_);
+  glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture_id_);
+  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  uniform_texture_ = glGetUniformLocation(shader_program_, "texture");
+
+  glGenBuffers(3, vertex_buffers_);
+  // Allocate vertices buffer.
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_[0]);
+  glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * 4, kVertices,
+               GL_STATIC_DRAW);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+  // Allocate triangle indices buffer.
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertex_buffers_[1]);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort) * 6, kIndices,
+               GL_STATIC_DRAW);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+  // Allocate texture coordinates buufer.
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_[2]);
+  glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 2 * 4, kTextureCoords,
+               GL_STATIC_DRAW);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+  // Assign the vertices attribute data.
+  attrib_vertices_ = glGetAttribLocation(shader_program_, "vertex");
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_[0]);
+  glEnableVertexAttribArray(attrib_vertices_);
+  glVertexAttribPointer(attrib_vertices_, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+  // Assign the texture coordinates attribute data.
+  attrib_texture_coords_ = glGetAttribLocation(shader_program_, "textureCoords");
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_[2]);
+  glEnableVertexAttribArray(attrib_texture_coords_);
+  glVertexAttribPointer(attrib_texture_coords_, 2, GL_FLOAT, GL_FALSE, 0,
+                        nullptr);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+  uniform_mvp_mat_ = glGetUniformLocation(shader_program_, "mvp");
+}
+
+void VideoOverlay::Render(const glm::mat4& projection_mat,
+                          const glm::mat4& view_mat) const {
+  glUseProgram(shader_program_);
+
+  glUniform1i(uniform_texture_, 0);
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture_id_);
+
+  glm::mat4 model_mat = GetTransformationMatrix();
+  glm::mat4 mvp_mat = projection_mat * view_mat * model_mat;
+  glUniformMatrix4fv(uniform_mvp_mat_, 1, GL_FALSE, glm::value_ptr(mvp_mat));
+
+  // Bind vertices buffer.
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_[0]);
+  glEnableVertexAttribArray(attrib_vertices_);
+  glVertexAttribPointer(attrib_vertices_, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+  // Bind texture coordinates buffer.
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers_[2]);
+  glEnableVertexAttribArray(attrib_texture_coords_);
+  glVertexAttribPointer(attrib_texture_coords_, 2, GL_FLOAT, GL_FALSE, 0,
+                        nullptr);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+  // Bind element array buffer.
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertex_buffers_[1]);
+  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
+  util::CheckGlError("glDrawElements");
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+  glUseProgram(0);
+  util::CheckGlError("glUseProgram()");
+}
+
+}  // namespace tango_gl

app/android/jni/third-party/include/glm/common.hpp

@@ -0,0 +1,31 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/common.hpp
+/// @date 2013-12-24 / 2013-12-24
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "detail/func_common.hpp"

app/android/jni/third-party/include/glm/detail/_features.hpp

@@ -0,0 +1,424 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/_features.hpp
+/// @date 2013-02-20 / 2013-02-20
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+// #define GLM_CXX98_EXCEPTIONS
+// #define GLM_CXX98_RTTI
+
+// #define GLM_CXX11_RVALUE_REFERENCES
+// Rvalue references - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html
+
+// GLM_CXX11_TRAILING_RETURN
+// Rvalue references for *this - GCC not supported
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm
+
+// GLM_CXX11_NONSTATIC_MEMBER_INIT
+// Initialization of class objects by rvalues - GCC any
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html
+
+// GLM_CXX11_NONSTATIC_MEMBER_INIT
+// Non-static data member initializers - GCC 4.7
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm
+
+// #define GLM_CXX11_VARIADIC_TEMPLATE
+// Variadic templates - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf
+
+// 
+// Extending variadic template template parameters - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf
+
+// #define GLM_CXX11_GENERALIZED_INITIALIZERS
+// Initializer lists - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm
+
+// #define GLM_CXX11_STATIC_ASSERT 
+// Static assertions - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html
+
+// #define GLM_CXX11_AUTO_TYPE
+// auto-typed variables - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf
+
+// #define GLM_CXX11_AUTO_TYPE
+// Multi-declarator auto - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf
+
+// #define GLM_CXX11_AUTO_TYPE
+// Removal of auto as a storage-class specifier - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm
+
+// #define GLM_CXX11_AUTO_TYPE
+// New function declarator syntax - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm
+
+// #define GLM_CXX11_LAMBDAS
+// New wording for C++0x lambdas - GCC 4.5
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf
+
+// #define GLM_CXX11_DECLTYPE
+// Declared type of an expression - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf
+
+// 
+// Right angle brackets - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html
+
+// 
+// Default template arguments for function templates	DR226	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226
+
+// 
+// Solving the SFINAE problem for expressions	DR339	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html
+
+// #define GLM_CXX11_ALIAS_TEMPLATE
+// Template aliases	N2258	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
+
+// 
+// Extern templates	N1987	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm
+
+// #define GLM_CXX11_NULLPTR
+// Null pointer constant	N2431	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf
+
+// #define GLM_CXX11_STRONG_ENUMS
+// Strongly-typed enums	N2347	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf
+
+// 
+// Forward declarations for enums	N2764	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf
+
+// 
+// Generalized attributes	N2761	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf
+
+// 
+// Generalized constant expressions	N2235	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf
+
+// 
+// Alignment support	N2341	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
+
+// #define GLM_CXX11_DELEGATING_CONSTRUCTORS
+// Delegating constructors	N1986	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf
+
+// 
+// Inheriting constructors	N2540	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm
+
+// #define GLM_CXX11_EXPLICIT_CONVERSIONS
+// Explicit conversion operators	N2437	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
+
+// 
+// New character types	N2249	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html
+
+// 
+// Unicode string literals	N2442	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
+// 
+// Raw string literals	N2442	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
+// 
+// Universal character name literals	N2170	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html
+
+// #define GLM_CXX11_USER_LITERALS
+// User-defined literals		N2765	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf
+
+// 
+// Standard Layout Types	N2342	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm
+
+// #define GLM_CXX11_DEFAULTED_FUNCTIONS
+// #define GLM_CXX11_DELETED_FUNCTIONS
+// Defaulted and deleted functions	N2346	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm
+
+// 
+// Extended friend declarations	N1791	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf
+
+// 
+// Extending sizeof	N2253	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html
+
+// #define GLM_CXX11_INLINE_NAMESPACES
+// Inline namespaces	N2535	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm
+
+// #define GLM_CXX11_UNRESTRICTED_UNIONS
+// Unrestricted unions	N2544	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
+
+// #define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+// Local and unnamed types as template arguments	N2657	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm
+
+// #define GLM_CXX11_RANGE_FOR
+// Range-based for	N2930	GCC 4.6
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html
+
+// #define GLM_CXX11_OVERRIDE_CONTROL
+// Explicit virtual overrides	N2928 N3206 N3272	GCC 4.7
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm
+
+// 
+// Minimal support for garbage collection and reachability-based leak detection	N2670	No
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm
+
+// #define GLM_CXX11_NOEXCEPT
+// Allowing move constructors to throw [noexcept]	N3050	GCC 4.6 (core language only)
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html
+
+// 
+// Defining move special member functions	N3053	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html
+
+// 
+// Sequence points	N2239	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
+// 
+// Atomic operations	N2427	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
+// 
+// Strong Compare and Exchange	N2748	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
+
+// 
+// Bidirectional Fences	N2752	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm
+
+// 
+// Memory model	N2429	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm
+
+// 
+// Data-dependency ordering: atomics and memory model	N2664	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm
+
+// 
+// Propagating exceptions	N2179	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html
+
+// 
+// Abandoning a process and at_quick_exit	N2440	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm
+
+// 
+// Allow atomics use in signal handlers	N2547	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm
+
+// 
+// Thread-local storage	N2659	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm
+
+// 
+// Dynamic initialization and destruction with concurrency	N2660	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm
+
+// 
+// __func__ predefined identifier	N2340	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm
+
+// 
+// C99 preprocessor	N1653	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm
+
+// 
+// long long	N1811	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf
+
+// 
+// Extended integral types	N1988	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf
+
+#if(GLM_COMPILER & GLM_COMPILER_GCC)
+
+#	if(GLM_COMPILER >= GLM_COMPILER_GCC43)
+#		define GLM_CXX11_STATIC_ASSERT
+#	endif
+
+#elif(GLM_COMPILER & GLM_COMPILER_CLANG)
+#	if(__has_feature(cxx_exceptions))
+#		define GLM_CXX98_EXCEPTIONS
+#	endif
+
+#	if(__has_feature(cxx_rtti))
+#		define GLM_CXX98_RTTI
+#	endif
+
+#	if(__has_feature(cxx_access_control_sfinae))
+#		define GLM_CXX11_ACCESS_CONTROL_SFINAE
+#	endif
+
+#	if(__has_feature(cxx_alias_templates))
+#		define GLM_CXX11_ALIAS_TEMPLATE
+#	endif
+
+#	if(__has_feature(cxx_alignas))
+#		define GLM_CXX11_ALIGNAS
+#	endif
+
+#	if(__has_feature(cxx_attributes))
+#		define GLM_CXX11_ATTRIBUTES
+#	endif
+
+#	if(__has_feature(cxx_constexpr))
+#		define GLM_CXX11_CONSTEXPR
+#	endif
+
+#	if(__has_feature(cxx_decltype))
+#		define GLM_CXX11_DECLTYPE
+#	endif
+
+#	if(__has_feature(cxx_default_function_template_args))
+#		define GLM_CXX11_DEFAULT_FUNCTION_TEMPLATE_ARGS
+#	endif
+
+#	if(__has_feature(cxx_defaulted_functions))
+#		define GLM_CXX11_DEFAULTED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_delegating_constructors))
+#		define GLM_CXX11_DELEGATING_CONSTRUCTORS
+#	endif
+
+#	if(__has_feature(cxx_deleted_functions))
+#		define GLM_CXX11_DELETED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_explicit_conversions))
+#		define GLM_CXX11_EXPLICIT_CONVERSIONS
+#	endif
+
+#	if(__has_feature(cxx_generalized_initializers))
+#		define GLM_CXX11_GENERALIZED_INITIALIZERS
+#	endif
+
+#	if(__has_feature(cxx_implicit_moves))
+#		define GLM_CXX11_IMPLICIT_MOVES
+#	endif
+
+#	if(__has_feature(cxx_inheriting_constructors))
+#		define GLM_CXX11_INHERITING_CONSTRUCTORS
+#	endif
+
+#	if(__has_feature(cxx_inline_namespaces))
+#		define GLM_CXX11_INLINE_NAMESPACES
+#	endif
+
+#	if(__has_feature(cxx_lambdas))
+#		define GLM_CXX11_LAMBDAS
+#	endif
+
+#	if(__has_feature(cxx_local_type_template_args))
+#		define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+#	endif
+
+#	if(__has_feature(cxx_noexcept))
+#		define GLM_CXX11_NOEXCEPT
+#	endif
+
+#	if(__has_feature(cxx_nonstatic_member_init))
+#		define GLM_CXX11_NONSTATIC_MEMBER_INIT
+#	endif
+
+#	if(__has_feature(cxx_nullptr))
+#		define GLM_CXX11_NULLPTR
+#	endif
+
+#	if(__has_feature(cxx_override_control))
+#		define GLM_CXX11_OVERRIDE_CONTROL
+#	endif
+
+#	if(__has_feature(cxx_reference_qualified_functions))
+#		define GLM_CXX11_REFERENCE_QUALIFIED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_range_for))
+#		define GLM_CXX11_RANGE_FOR
+#	endif
+
+#	if(__has_feature(cxx_raw_string_literals))
+#		define GLM_CXX11_RAW_STRING_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_rvalue_references))
+#		define GLM_CXX11_RVALUE_REFERENCES
+#	endif
+
+#	if(__has_feature(cxx_static_assert))
+#		define GLM_CXX11_STATIC_ASSERT
+#	endif
+
+#	if(__has_feature(cxx_auto_type))
+#		define GLM_CXX11_AUTO_TYPE
+#	endif
+
+#	if(__has_feature(cxx_strong_enums))
+#		define GLM_CXX11_STRONG_ENUMS
+#	endif
+
+#	if(__has_feature(cxx_trailing_return))
+#		define GLM_CXX11_TRAILING_RETURN
+#	endif
+
+#	if(__has_feature(cxx_unicode_literals))
+#		define GLM_CXX11_UNICODE_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_unrestricted_unions))
+#		define GLM_CXX11_UNRESTRICTED_UNIONS
+#	endif
+
+#	if(__has_feature(cxx_user_literals))
+#		define GLM_CXX11_USER_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_variadic_templates))
+#		define GLM_CXX11_VARIADIC_TEMPLATES
+#	endif
+
+#endif//(GLM_COMPILER & GLM_COMPILER_CLANG)

app/android/jni/third-party/include/glm/detail/_fixes.hpp

@@ -0,0 +1,55 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/_fixes.hpp
+/// @date 2011-02-21 / 2011-11-22
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <cmath>
+
+//! Workaround for compatibility with other libraries
+#ifdef max
+#undef max
+#endif
+
+//! Workaround for compatibility with other libraries
+#ifdef min
+#undef min
+#endif
+
+//! Workaround for Android
+#ifdef isnan
+#undef isnan
+#endif
+
+//! Workaround for Android
+#ifdef isinf
+#undef isinf
+#endif
+
+//! Workaround for Chrone Native Client
+#ifdef log2
+#undef log2
+#endif
+

app/android/jni/third-party/include/glm/detail/_literals.hpp

@@ -0,0 +1,48 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/_literals.hpp
+/// @date 2013-05-06 / 2013-05-06
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+namespace glm
+{
+#define GLM_CXX11_USER_LITERALS
+#ifdef GLM_CXX11_USER_LITERALS
+/*
+	GLM_FUNC_QUALIFIER detail::half operator "" _h(long double const s)
+	{
+		return detail::half(s);
+	}
+
+	GLM_FUNC_QUALIFIER float operator "" _f(long double const s)
+	{
+		return static_cast<float>(s);
+	}
+*/
+#endif//GLM_CXX11_USER_LITERALS
+
+}//namespace glm

app/android/jni/third-party/include/glm/detail/_noise.hpp

@@ -0,0 +1,127 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/_noise.hpp
+/// @date 2013-12-24 / 2013-12-24
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER T mod289(T const & x)
+	{
+		return x - floor(x * static_cast<T>(1.0) / static_cast<T>(289.0)) * static_cast<T>(289.0);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T permute(T const & x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P> permute(tvec2<T, P> const & x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> permute(tvec3<T, P> const & x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> permute(tvec4<T, P> const & x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+/*
+	template <typename T, precision P, template<typename> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> permute(vecType<T, P> const & x)
+	{
+		return mod289(((x * T(34)) + T(1)) * x);
+	}
+*/
+	template <typename T>
+	GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> taylorInvSqrt(detail::tvec2<T, P> const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> taylorInvSqrt(detail::tvec3<T, P> const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> taylorInvSqrt(detail::tvec4<T, P> const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+/*
+	template <typename T, precision P, template<typename> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> taylorInvSqrt(vecType<T, P> const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+*/
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> fade(detail::tvec2<T, P> const & t)
+	{
+		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> fade(detail::tvec3<T, P> const & t)
+	{
+		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> fade(detail::tvec4<T, P> const & t)
+	{
+		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
+	}
+/*
+	template <typename T, precision P, template <typename> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fade(vecType<T, P> const & t)
+	{
+		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
+	}
+*/
+}//namespace detail
+}//namespace glm
+

app/android/jni/third-party/include/glm/detail/_swizzle.hpp

@@ -0,0 +1,837 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/_swizzle.hpp
+/// @date 2006-04-20 / 2011-02-16
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+namespace glm{
+namespace detail
+{
+	// Internal class for implementing swizzle operators
+	template <typename T, int N>
+	struct _swizzle_base0
+	{
+		typedef T       value_type;
+
+	protected:
+		GLM_FUNC_QUALIFIER value_type&         elem   (size_t i)       { return (reinterpret_cast<value_type*>(_buffer))[i]; }
+		GLM_FUNC_QUALIFIER const value_type&   elem   (size_t i) const { return (reinterpret_cast<const value_type*>(_buffer))[i]; }
+
+		// Use an opaque buffer to *ensure* the compiler doesn't call a constructor.
+		// The size 1 buffer is assumed to aligned to the actual members so that the
+		// elem() 
+		char    _buffer[1];
+	};
+
+	template <typename T, precision P, typename V, int E0, int E1, int E2, int E3, int N>
+	struct _swizzle_base1 : public _swizzle_base0<T, N>
+	{
+	};
+
+	template <typename T, precision P, typename V, int E0, int E1>
+	struct _swizzle_base1<T, P, V,E0,E1,-1,-2,2> : public _swizzle_base0<T, 2>
+	{
+		GLM_FUNC_QUALIFIER V operator ()()  const { return V(this->elem(E0), this->elem(E1)); }
+	};
+
+	template <typename T, precision P, typename V, int E0, int E1, int E2>
+	struct _swizzle_base1<T, P, V,E0,E1,E2,-1,3> : public _swizzle_base0<T, 3>
+	{
+		GLM_FUNC_QUALIFIER V operator ()()  const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); }
+	};
+
+	template <typename T, precision P, typename V, int E0, int E1, int E2, int E3>
+	struct _swizzle_base1<T, P, V,E0,E1,E2,E3,4> : public _swizzle_base0<T, 4>
+	{ 
+		GLM_FUNC_QUALIFIER V operator ()()  const { return V(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
+	};
+
+	// Internal class for implementing swizzle operators
+	/*
+		Template parameters:
+
+		ValueType = type of scalar values (e.g. float, double)
+		VecType   = class the swizzle is applies to (e.g. tvec3<float>)
+		N         = number of components in the vector (e.g. 3)
+		E0...3    = what index the n-th element of this swizzle refers to in the unswizzled vec
+
+		DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
+			containing duplicate elements so that they cannot be used as r-values).            
+	*/
+	template <typename ValueType, precision P, typename VecType, int N, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
+	struct _swizzle_base2 : public _swizzle_base1<ValueType, P, VecType,E0,E1,E2,E3,N>
+	{
+		typedef VecType vec_type;
+		typedef ValueType value_type;
+
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const ValueType& t)
+		{
+			for (int i = 0; i < N; ++i)
+				(*this)[i] = t;
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const VecType& that)
+		{
+			struct op { 
+				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e = t; } 
+			};
+			_apply_op(that, op());
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER void operator -= (const VecType& that)
+		{
+			struct op { 
+				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e -= t; } 
+			};
+			_apply_op(that, op());
+		}
+
+		GLM_FUNC_QUALIFIER void operator += (const VecType& that)
+		{
+			struct op { 
+				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e += t; } 
+			};
+			_apply_op(that, op());
+		}
+
+		GLM_FUNC_QUALIFIER void operator *= (const VecType& that)
+		{
+			struct op { 
+				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e *= t; } 
+			};
+			_apply_op(that, op());
+		}
+
+		GLM_FUNC_QUALIFIER void operator /= (const VecType& that)
+		{
+			struct op { 
+				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e /= t; } 
+			};
+			_apply_op(that, op());
+		}
+
+		GLM_FUNC_QUALIFIER value_type& operator[]  (size_t i)
+		{
+#ifndef __CUDA_ARCH__
+			static
+#endif
+				const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+		GLM_FUNC_QUALIFIER value_type  operator[]  (size_t i) const
+		{
+#ifndef __CUDA_ARCH__
+			static
+#endif
+				const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+	protected:
+		template <typename T>
+		GLM_FUNC_QUALIFIER void _apply_op(const VecType& that, T op)
+		{
+			// Make a copy of the data in this == &that.
+			// The copier should optimize out the copy in cases where the function is
+			// properly inlined and the copy is not necessary.
+			ValueType t[N];
+			for (int i = 0; i < N; ++i)
+				t[i] = that[i];
+			for (int i = 0; i < N; ++i)
+				op( (*this)[i], t[i] );
+		}
+	};
+
+	// Specialization for swizzles containing duplicate elements.  These cannot be modified.
+	template <typename ValueType, precision P, typename VecType, int N, int E0, int E1, int E2, int E3>
+	struct _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,1> : public _swizzle_base1<ValueType, P, VecType,E0,E1,E2,E3,N>
+	{
+		typedef VecType         vec_type;        
+		typedef ValueType       value_type;
+
+		struct Stub {};
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { return *this; }
+
+		GLM_FUNC_QUALIFIER value_type  operator[]  (size_t i) const
+		{
+#ifndef __CUDA_ARCH__
+			static
+#endif
+				const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+	};
+
+	template <int N,typename ValueType, precision P, typename VecType, int E0,int E1,int E2,int E3>
+	struct _swizzle : public _swizzle_base2<ValueType, P, VecType, N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)>
+	{
+		typedef _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)> base_type;
+
+		using base_type::operator=;
+
+		GLM_FUNC_QUALIFIER operator VecType () const { return (*this)(); }
+	};
+
+//
+// To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
+//
+#define _GLM_SWIZZLE_TEMPLATE1   template <int N, typename T, precision P, typename V, int E0, int E1, int E2, int E3>
+#define _GLM_SWIZZLE_TEMPLATE2   template <int N, typename T, precision P, typename V, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
+#define _GLM_SWIZZLE_TYPE1       _swizzle<N, T, P, V, E0, E1, E2, E3>
+#define _GLM_SWIZZLE_TYPE2       _swizzle<N, T, P, V, F0, F1, F2, F3>
+
+//
+// Wrapper for a binary operator (e.g. u.yy + v.zy)
+//
+#define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
+	_GLM_SWIZZLE_TEMPLATE2                                                          \
+	GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b)  \
+	{                                                                               \
+		return a() OPERAND b();                                                     \
+	}                                                                               \
+	_GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b)                   \
+	{                                                                               \
+		return a() OPERAND b;                                                       \
+	}                                                                               \
+	_GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER V operator OPERAND ( const V& a, const _GLM_SWIZZLE_TYPE1& b)                   \
+	{                                                                               \
+		return a OPERAND b();                                                       \
+	}
+
+//
+// Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz)
+//
+#define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
+	_GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b)                   \
+	{                                                                               \
+		return a() OPERAND b;                                                       \
+	}                                                                               \
+	_GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER V operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b)                   \
+	{                                                                               \
+		return a OPERAND b();                                                       \
+	}
+
+//
+// Macro for wrapping a function taking one argument (e.g. abs())
+//
+#define _GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION)                          \
+	_GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a)  \
+	{                                                                               \
+		return FUNCTION(a());                                                       \
+	}
+
+//
+// Macro for wrapping a function taking two vector arguments (e.g. dot()).
+//
+#define _GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION)                                                      \
+	_GLM_SWIZZLE_TEMPLATE2                                                                                      \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
+	{                                                                                                           \
+		return FUNCTION(a(), b());                                                                              \
+	}                                                                                                           \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \
+	{                                                                                                           \
+		return FUNCTION(a(), b());                                                                              \
+	}                                                                                                           \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b)         \
+	{                                                                                                           \
+		return FUNCTION(a(), b);                                                                                \
+	}                                                                                                           \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b)                  \
+	{                                                                                                           \
+		return FUNCTION(a, b());                                                                                \
+	} 
+
+//
+// Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()).
+//
+#define _GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION)                                                             \
+	_GLM_SWIZZLE_TEMPLATE2                                                                                                    \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b, const T& c)   \
+	{                                                                                                                         \
+		return FUNCTION(a(), b(), c);                                                                                         \
+	}                                                                                                                         \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b, const T& c)   \
+	{                                                                                                                         \
+		return FUNCTION(a(), b(), c);                                                                                         \
+	}                                                                                                                         \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\
+	{                                                                                                                         \
+		return FUNCTION(a(), b, c);                                                                                           \
+	}                                                                                                                         \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const _GLM_SWIZZLE_TYPE1& b, const T& c)           \
+	{                                                                                                                         \
+		return FUNCTION(a, b(), c);                                                                                           \
+	} 
+ 
+}//namespace detail 
+}//namespace glm
+
+namespace glm
+{
+	namespace detail
+	{
+		_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-)
+		_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*)
+		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+)
+		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-)
+		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*)
+		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/)
+	}
+
+	//
+	// Swizzles are distinct types from the unswizzled type.  The below macros will
+	// provide template specializations for the swizzle types for the given functions
+	// so that the compiler does not have any ambiguity to choosing how to handle
+	// the function.
+	//
+	// The alternative is to use the operator()() when calling the function in order
+	// to explicitly convert the swizzled type to the unswizzled type.
+	//
+
+	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    abs);
+	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acos);
+	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acosh);
+	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    all);
+	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    any);
+
+	//_GLM_SWIZZLE_FUNCTION_2_ARGS(value_type,  dot);
+	//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    cross);
+	//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    step);    
+	//_GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
+}
+
+#define _GLM_SWIZZLE2_2_MEMBERS(T, P, V, E0,E1) \
+	struct { _swizzle<2, T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
+	struct { _swizzle<2, T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
+	struct { _swizzle<2, T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
+	struct { _swizzle<2, T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; }; 
+
+#define _GLM_SWIZZLE2_3_MEMBERS(T, P, V, E0,E1) \
+	struct { _swizzle<3,T, P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { _swizzle<3,T, P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { _swizzle<3,T, P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { _swizzle<3,T, P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { _swizzle<3,T, P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { _swizzle<3,T, P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { _swizzle<3,T, P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { _swizzle<3,T, P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; };  
+
+#define _GLM_SWIZZLE2_4_MEMBERS(T, P, V, E0,E1) \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; };  
+
+#define _GLM_SWIZZLE3_2_MEMBERS(T, P, V, E0,E1,E2) \
+	struct { _swizzle<2,T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 0,2,-1,-2> E0 ## E2; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 1,2,-1,-2> E1 ## E2; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 2,0,-1,-2> E2 ## E0; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 2,1,-1,-2> E2 ## E1; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 2,2,-1,-2> E2 ## E2; }; 
+
+#define _GLM_SWIZZLE3_3_MEMBERS(T, P, V ,E0,E1,E2) \
+	struct { _swizzle<3,T,P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,0,2,-1> E0 ## E0 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,1,2,-1> E0 ## E1 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,2,0,-1> E0 ## E2 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,2,1,-1> E0 ## E2 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,2,2,-1> E0 ## E2 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,0,2,-1> E1 ## E0 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,1,2,-1> E1 ## E1 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,2,0,-1> E1 ## E2 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,2,1,-1> E1 ## E2 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,2,2,-1> E1 ## E2 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,0,0,-1> E2 ## E0 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,0,1,-1> E2 ## E0 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,0,2,-1> E2 ## E0 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,1,0,-1> E2 ## E1 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,1,1,-1> E2 ## E1 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,1,2,-1> E2 ## E1 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,2,0,-1> E2 ## E2 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,2,1,-1> E2 ## E2 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,2,2,-1> E2 ## E2 ## E2; };
+
+#define _GLM_SWIZZLE3_4_MEMBERS(T, P, V, E0,E1,E2) \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+	struct { _swizzle<4,T, P, V<T, P>, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; 
+
+#define _GLM_SWIZZLE4_2_MEMBERS(T, P, V, E0,E1,E2,E3) \
+	struct { _swizzle<2,T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 0,2,-1,-2> E0 ## E2; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 0,3,-1,-2> E0 ## E3; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 1,2,-1,-2> E1 ## E2; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 1,3,-1,-2> E1 ## E3; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 2,0,-1,-2> E2 ## E0; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 2,1,-1,-2> E2 ## E1; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 2,2,-1,-2> E2 ## E2; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 2,3,-1,-2> E2 ## E3; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 3,0,-1,-2> E3 ## E0; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 3,1,-1,-2> E3 ## E1; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 3,2,-1,-2> E3 ## E2; }; \
+	struct { _swizzle<2,T, P, V<T, P>, 3,3,-1,-2> E3 ## E3; }; 
+
+#define _GLM_SWIZZLE4_3_MEMBERS(T,P, V, E0,E1,E2,E3) \
+	struct { _swizzle<3,T,P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,0,2,-1> E0 ## E0 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,0,3,-1> E0 ## E0 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,1,2,-1> E0 ## E1 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,1,3,-1> E0 ## E1 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,2,0,-1> E0 ## E2 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,2,1,-1> E0 ## E2 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,2,2,-1> E0 ## E2 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,2,3,-1> E0 ## E2 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,3,0,-1> E0 ## E3 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,3,1,-1> E0 ## E3 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,3,2,-1> E0 ## E3 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 0,3,3,-1> E0 ## E3 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,0,2,-1> E1 ## E0 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,0,3,-1> E1 ## E0 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,1,2,-1> E1 ## E1 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,1,3,-1> E1 ## E1 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,2,0,-1> E1 ## E2 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,2,1,-1> E1 ## E2 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,2,2,-1> E1 ## E2 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,2,3,-1> E1 ## E2 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,3,0,-1> E1 ## E3 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,3,1,-1> E1 ## E3 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,3,2,-1> E1 ## E3 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 1,3,3,-1> E1 ## E3 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,0,0,-1> E2 ## E0 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,0,1,-1> E2 ## E0 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,0,2,-1> E2 ## E0 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,0,3,-1> E2 ## E0 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,1,0,-1> E2 ## E1 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,1,1,-1> E2 ## E1 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,1,2,-1> E2 ## E1 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,1,3,-1> E2 ## E1 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,2,0,-1> E2 ## E2 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,2,1,-1> E2 ## E2 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,2,2,-1> E2 ## E2 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,2,3,-1> E2 ## E2 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,3,0,-1> E2 ## E3 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,3,1,-1> E2 ## E3 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,3,2,-1> E2 ## E3 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 2,3,3,-1> E2 ## E3 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,0,0,-1> E3 ## E0 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,0,1,-1> E3 ## E0 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,0,2,-1> E3 ## E0 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,0,3,-1> E3 ## E0 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,1,0,-1> E3 ## E1 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,1,1,-1> E3 ## E1 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,1,2,-1> E3 ## E1 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,1,3,-1> E3 ## E1 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,2,0,-1> E3 ## E2 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,2,1,-1> E3 ## E2 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,2,2,-1> E3 ## E2 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,2,3,-1> E3 ## E2 ## E3; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,3,0,-1> E3 ## E3 ## E0; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,3,1,-1> E3 ## E3 ## E1; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,3,2,-1> E3 ## E3 ## E2; }; \
+	struct { _swizzle<3,T,P, V<T, P>, 3,3,3,-1> E3 ## E3 ## E3; };  
+
+#define _GLM_SWIZZLE4_4_MEMBERS(T, P, V, E0,E1,E2,E3) \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,3,3> E3 ## E3 ## E3 ## E3; };

app/android/jni/third-party/include/glm/detail/_swizzle_func.hpp

@@ -0,0 +1,721 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/_swizzle_func.hpp
+/// @date 2011-10-16 / 2011-10-16
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B)	\
+	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B() CONST												\
+	{																								\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B);								\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C)		\
+	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B ## C() CONST												\
+	{																									\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C);							\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D)	\
+	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B ## C ## D() CONST										\
+	{																									\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C, this->D);					\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B)	\
+	template <typename TMPL_TYPE>																		\
+	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B() CONST							\
+	{																									\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B);									\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C)		\
+	template <typename TMPL_TYPE>																			\
+	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B ## C() CONST							\
+	{																										\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C);								\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D)	\
+	template <typename TMPL_TYPE>																			\
+	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B ## C ## D() CONST						\
+	{																										\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C, this->D);						\
+	}
+
+#define GLM_MUTABLE
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, x, y) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, r, g) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, s, t)
+
+//GLM_SWIZZLE_GEN_REF_FROM_VEC2(valType, detail::vec2, detail::ref2)
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B)
+
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, x, y, z) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, r, g, b) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, s, t, p)
+
+//GLM_SWIZZLE_GEN_REF_FROM_VEC3(valType, detail::vec3, detail::ref2, detail::ref3)
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, C)
+
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B)
+
+#define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
+
+//GLM_SWIZZLE_GEN_REF_FROM_VEC4(valType, detail::vec4, detail::ref2, detail::ref3, detail::ref4)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE)			\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y)	\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g)	\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t)
+
+//GLM_SWIZZLE_GEN_VEC_FROM_VEC2(valType, detail::vec2, detail::vec2, detail::vec3, detail::vec4)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p)
+
+//GLM_SWIZZLE_GEN_VEC_FROM_VEC3(valType, detail::vec3, detail::vec2, detail::vec3, detail::vec4)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
+
+//GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4)

app/android/jni/third-party/include/glm/detail/_vectorize.hpp

@@ -0,0 +1,227 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/_vectorize.hpp
+/// @date 2011-10-14 / 2011-10-14
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "type_vec1.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+
+#define VECTORIZE1_VEC(func)						\
+	template <typename T, precision P>				\
+	GLM_FUNC_QUALIFIER detail::tvec1<T, P> func(	\
+		detail::tvec1<T, P> const & v)				\
+	{												\
+		return detail::tvec1<T, P>(					\
+			func(v.x));								\
+	}
+
+#define VECTORIZE2_VEC(func)						\
+	template <typename T, precision P>				\
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func(	\
+		detail::tvec2<T, P> const & v)				\
+	{												\
+		return detail::tvec2<T, P>(					\
+			func(v.x),								\
+			func(v.y));								\
+	}
+
+#define VECTORIZE3_VEC(func)						\
+	template <typename T, precision P>				\
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func(	\
+		detail::tvec3<T, P> const & v)				\
+	{												\
+		return detail::tvec3<T, P>(					\
+			func(v.x),								\
+			func(v.y),								\
+			func(v.z));								\
+	}
+
+#define VECTORIZE4_VEC(func)						\
+	template <typename T, precision P>				\
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func(	\
+		detail::tvec4<T, P> const & v)				\
+	{												\
+		return detail::tvec4<T, P>(					\
+			func(v.x),								\
+			func(v.y),								\
+			func(v.z),								\
+			func(v.w));								\
+	}
+
+#define VECTORIZE_VEC(func)		\
+	VECTORIZE1_VEC(func)		\
+	VECTORIZE2_VEC(func)		\
+	VECTORIZE3_VEC(func)		\
+	VECTORIZE4_VEC(func)
+
+#define VECTORIZE1_VEC_SCA(func)							\
+	template <typename T, precision P>						\
+	GLM_FUNC_QUALIFIER detail::tvec1<T, P> func				\
+	(														\
+		detail::tvec1<T, P> const & x,						\
+		typename detail::tvec1<T, P>::value_type const & y	\
+	)														\
+	{														\
+		return detail::tvec1<T, P>(							\
+			func(x.x, y));									\
+	}
+
+#define VECTORIZE2_VEC_SCA(func)							\
+	template <typename T, precision P>						\
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func				\
+	(														\
+		detail::tvec2<T, P> const & x,						\
+		typename detail::tvec2<T, P>::value_type const & y	\
+	)														\
+	{														\
+		return detail::tvec2<T, P>(							\
+			func(x.x, y),									\
+			func(x.y, y));									\
+	}
+
+#define VECTORIZE3_VEC_SCA(func)							\
+	template <typename T, precision P>						\
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func				\
+	(														\
+		detail::tvec3<T, P> const & x,						\
+		typename detail::tvec3<T, P>::value_type const & y	\
+	)														\
+	{														\
+		return detail::tvec3<T, P>(							\
+			func(x.x, y),									\
+			func(x.y, y),									\
+			func(x.z, y));									\
+	}
+
+#define VECTORIZE4_VEC_SCA(func)							\
+	template <typename T, precision P>						\
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func				\
+	(														\
+		detail::tvec4<T, P> const & x,						\
+		typename detail::tvec4<T, P>::value_type const & y	\
+	)														\
+	{														\
+		return detail::tvec4<T, P>(							\
+			func(x.x, y),									\
+			func(x.y, y),									\
+			func(x.z, y),									\
+			func(x.w, y));									\
+	}
+
+#define VECTORIZE_VEC_SCA(func)		\
+	VECTORIZE1_VEC_SCA(func)		\
+	VECTORIZE2_VEC_SCA(func)		\
+	VECTORIZE3_VEC_SCA(func)		\
+	VECTORIZE4_VEC_SCA(func)
+
+#define VECTORIZE1_VEC_VEC(func)					\
+	template <typename T, precision P>				\
+	GLM_FUNC_QUALIFIER detail::tvec1<T, P> func		\
+	(												\
+		detail::tvec1<T, P> const & x,				\
+		detail::tvec1<T, P> const & y				\
+	)												\
+	{												\
+		return detail::tvec1<T, P>(					\
+			func(x.x, y.x));						\
+	}
+
+#define VECTORIZE2_VEC_VEC(func)					\
+	template <typename T, precision P>				\
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func		\
+	(												\
+		detail::tvec2<T, P> const & x,				\
+		detail::tvec2<T, P> const & y				\
+	)												\
+	{												\
+		return detail::tvec2<T, P>(					\
+			func(x.x, y.x),							\
+			func(x.y, y.y));						\
+	}
+
+#define VECTORIZE3_VEC_VEC(func)					\
+	template <typename T, precision P>				\
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func		\
+	(												\
+		detail::tvec3<T, P> const & x,				\
+		detail::tvec3<T, P> const & y				\
+	)												\
+	{												\
+		return detail::tvec3<T, P>(					\
+			func(x.x, y.x),							\
+			func(x.y, y.y),							\
+			func(x.z, y.z));						\
+	}
+
+#define VECTORIZE4_VEC_VEC(func)				\
+	template <typename T, precision P>			\
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func	\
+	(											\
+		detail::tvec4<T, P> const & x,			\
+		detail::tvec4<T, P> const & y			\
+	)											\
+	{											\
+		return detail::tvec4<T, P>(				\
+			func(x.x, y.x),						\
+			func(x.y, y.y),						\
+			func(x.z, y.z),						\
+			func(x.w, y.w));					\
+	}
+
+#define VECTORIZE_VEC_VEC(func)		\
+	VECTORIZE1_VEC_VEC(func)		\
+	VECTORIZE2_VEC_VEC(func)		\
+	VECTORIZE3_VEC_VEC(func)		\
+	VECTORIZE4_VEC_VEC(func)
+
+namespace glm{
+namespace detail
+{
+	template<bool C>
+	struct If
+	{
+		template<typename F, typename T>
+		static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
+		{
+			return functor(val);
+		}
+	};
+
+	template<>
+	struct If<false>
+	{
+		template<typename F, typename T>
+		static GLM_FUNC_QUALIFIER T apply(F, const T& val)
+		{
+			return val;
+		}
+	};
+}//namespace detail
+}//namespace glm

app/android/jni/third-party/include/glm/detail/dummy.cpp

@@ -0,0 +1,191 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/dummy.cpp
+/// @date 2011-01-19 / 2011-06-15
+/// @author Christophe Riccio
+///
+/// GLM is a header only library. There is nothing to compile. 
+/// dummy.cpp exist only a wordaround for CMake file.
+///////////////////////////////////////////////////////////////////////////////////
+
+#define GLM_MESSAGES
+#include "../glm.hpp"
+#include <limits>
+
+struct material
+{
+	glm::vec4 emission; // Ecm
+	glm::vec4 ambient; // Acm
+	glm::vec4 diffuse; // Dcm
+	glm::vec4 specular; // Scm
+	float shininess; // Srm
+};
+
+struct light
+{
+	glm::vec4 ambient; // Acli
+	glm::vec4 diffuse; // Dcli
+	glm::vec4 specular; // Scli
+	glm::vec4 position; // Ppli
+	glm::vec4 halfVector; // Derived: Hi
+	glm::vec3 spotDirection; // Sdli
+	float spotExponent; // Srli
+	float spotCutoff; // Crli
+	// (range: [0.0,90.0], 180.0)
+	float spotCosCutoff; // Derived: cos(Crli)
+	// (range: [1.0,0.0],-1.0)
+	float constantAttenuation; // K0
+	float linearAttenuation; // K1
+	float quadraticAttenuation;// K2
+};
+
+
+// Sample 1
+#include <glm/vec3.hpp>// glm::vec3
+#include <glm/geometric.hpp>// glm::cross, glm::normalize
+
+glm::vec3 computeNormal
+(
+	glm::vec3 const & a,
+	glm::vec3 const & b,
+	glm::vec3 const & c
+)
+{
+	return glm::normalize(glm::cross(c - a, b - a));
+}
+
+typedef unsigned int GLuint;
+#define GL_FALSE 0
+void glUniformMatrix4fv(GLuint, int, int, float*){}
+
+// Sample 2
+#include <glm/vec3.hpp> // glm::vec3
+#include <glm/vec4.hpp> // glm::vec4, glm::ivec4
+#include <glm/mat4x4.hpp> // glm::mat4
+#include <glm/gtc/matrix_transform.hpp> // glm::translate, glm::rotate, glm::scale, glm::perspective
+#include <glm/gtc/type_ptr.hpp> // glm::value_ptr
+void func(GLuint LocationMVP, float Translate, glm::vec2 const & Rotate)
+{
+	glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.f);
+	glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Translate));
+	glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Rotate.y, glm::vec3(-1.0f, 0.0f, 0.0f));
+	glm::mat4 View = glm::rotate(ViewRotateX, Rotate.x, glm::vec3(0.0f, 1.0f, 0.0f));
+	glm::mat4 Model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f));
+	glm::mat4 MVP = Projection * View * Model;
+	glUniformMatrix4fv(LocationMVP, 1, GL_FALSE, glm::value_ptr(MVP));
+}
+
+// Sample 3
+#include <glm/vec2.hpp>// glm::vec2
+#include <glm/packing.hpp>// glm::packUnorm2x16
+#include <glm/integer.hpp>// glm::uint
+#include <glm/gtc/type_precision.hpp>// glm::i8vec2, glm::i32vec2
+std::size_t const VertexCount = 4;
+// Float quad geometry
+std::size_t const PositionSizeF32 = VertexCount * sizeof(glm::vec2);
+glm::vec2 const PositionDataF32[VertexCount] =
+{
+	glm::vec2(-1.0f,-1.0f),
+	glm::vec2( 1.0f,-1.0f),
+	glm::vec2( 1.0f, 1.0f),
+	glm::vec2(-1.0f, 1.0f)
+	};
+// Half-float quad geometry
+std::size_t const PositionSizeF16 = VertexCount * sizeof(glm::uint);
+glm::uint const PositionDataF16[VertexCount] =
+{
+	glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, -1.0f))),
+	glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, -1.0f))),
+	glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, 1.0f))),
+	glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, 1.0f)))
+};
+// 8 bits signed integer quad geometry
+std::size_t const PositionSizeI8 = VertexCount * sizeof(glm::i8vec2);
+glm::i8vec2 const PositionDataI8[VertexCount] =
+{
+	glm::i8vec2(-1,-1),
+	glm::i8vec2( 1,-1),
+	glm::i8vec2( 1, 1),
+	glm::i8vec2(-1, 1)
+};
+// 32 bits signed integer quad geometry
+std::size_t const PositionSizeI32 = VertexCount * sizeof(glm::i32vec2);
+glm::i32vec2 const PositionDataI32[VertexCount] =
+{
+	glm::i32vec2 (-1,-1),
+	glm::i32vec2 ( 1,-1),
+	glm::i32vec2 ( 1, 1),
+	glm::i32vec2 (-1, 1)
+};
+
+struct intersection
+{
+	glm::vec4 position;
+	glm::vec3 normal;
+};
+
+/*
+// Sample 4
+#include <glm/vec3.hpp>// glm::vec3
+#include <glm/geometric.hpp>// glm::normalize, glm::dot, glm::reflect
+#include <glm/exponential.hpp>// glm::pow
+#include <glm/gtc/random.hpp>// glm::vecRand3
+glm::vec3 lighting
+(
+	intersection const & Intersection,
+	material const & Material,
+	light const & Light,
+	glm::vec3 const & View
+)
+{
+	glm::vec3 Color(0.0f);
+	glm::vec3 LightVertor(glm::normalize(
+		Light.position - Intersection.position +
+		glm::vecRand3(0.0f, Light.inaccuracy));
+
+	if(!shadow(Intersection.position, Light.position, LightVertor))
+	{
+		float Diffuse = glm::dot(Intersection.normal, LightVector);
+		if(Diffuse <= 0.0f)
+			return Color;
+		if(Material.isDiffuse())
+			Color += Light.color() * Material.diffuse * Diffuse;
+		if(Material.isSpecular())
+		{
+			glm::vec3 Reflect(glm::reflect(
+				glm::normalize(-LightVector),
+				glm::normalize(Intersection.normal)));
+			float Dot = glm::dot(Reflect, View);
+			float Base = Dot > 0.0f ? Dot : 0.0f;
+			float Specular = glm::pow(Base, Material.exponent);
+			Color += Material.specular * Specular;
+		}
+	}
+	return Color;
+}
+*/
+int main()
+{
+	return 0;
+}

app/android/jni/third-party/include/glm/detail/func_common.hpp

@@ -0,0 +1,470 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/func_common.hpp
+/// @date 2008-03-08 / 2010-01-26
+/// @author Christophe Riccio
+/// 
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+///
+/// @defgroup core_func_common Common functions
+/// @ingroup core
+/// 
+/// These all operate component-wise. The description is per component.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+#include "precision.hpp"
+#include "type_int.hpp"
+#include "_fixes.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_common
+	/// @{
+
+	/// Returns x if x >= 0; otherwise, it returns -x.
+	/// 
+	/// @tparam genType floating-point or signed integer; scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType abs(genType const & x);
+
+	/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. 
+	/// 
+	/// @tparam genType Floating-point or signed integer; scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType sign(genType const & x);
+	
+	/// Returns a value equal to the nearest integer that is less then or equal to x. 
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType floor(genType const & x);
+
+	/// Returns a value equal to the nearest integer to x
+	/// whose absolute value is not larger than the absolute value of x.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType trunc(genType const & x);
+
+	/// Returns a value equal to the nearest integer to x.
+	/// The fraction 0.5 will round in a direction chosen by the
+	/// implementation, presumably the direction that is fastest.
+	/// This includes the possibility that round(x) returns the
+	/// same value as roundEven(x) for all values of x.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType round(genType const & x);
+	
+	/// Returns a value equal to the nearest integer to x.
+	/// A fractional part of 0.5 will round toward the nearest even
+	/// integer. (Both 3.5 and 4.5 for x will return 4.0.)
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType roundEven(genType const & x);
+
+	/// Returns a value equal to the nearest integer
+	/// that is greater than or equal to x.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType ceil(genType const & x);
+
+	/// Return x - floor(x).
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType fract(genType const & x);
+
+	/// Modulus. Returns x - y * floor(x / y)
+	/// for each component in x using the floating point value y.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType mod(
+		genType const & x,
+		genType const & y);
+
+	/// Modulus. Returns x - y * floor(x / y)
+	/// for each component in x using the floating point value y.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType mod(
+		genType const & x,
+		typename genType::value_type const & y);
+
+	/// Returns the fractional part of x and sets i to the integer
+	/// part (as a whole number floating point value). Both the
+	/// return value and the output parameter will have the same
+	/// sign as x.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType modf(
+		genType const & x,
+		genType & i);
+
+	/// Returns y if y < x; otherwise, it returns x.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType min(
+		genType const & x,
+		genType const & y);
+
+	template <typename genType>
+	GLM_FUNC_DECL genType min(
+		genType const & x,
+		typename genType::value_type const & y);
+
+	/// Returns y if x < y; otherwise, it returns x.
+	/// 
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType max(
+		genType const & x,
+		genType const & y);
+
+	template <typename genType>
+	GLM_FUNC_DECL genType max(
+		genType const & x,
+		typename genType::value_type const & y);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x 
+	/// using the floating-point values minVal and maxVal.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType clamp(
+		genType const & x,
+		genType const & minVal,
+		genType const & maxVal);
+
+	template <typename genType, precision P>
+	GLM_FUNC_DECL genType clamp(
+		genType const & x,
+		typename genType::value_type const & minVal,
+		typename genType::value_type const & maxVal);
+
+	/// If genTypeU is a floating scalar or vector:
+	/// Returns x * (1.0 - a) + y * a, i.e., the linear blend of
+	/// x and y using the floating-point value a.
+	/// The value for a is not restricted to the range [0, 1].
+	/// 
+	/// If genTypeU is a boolean scalar or vector:
+	/// Selects which vector each returned component comes
+	/// from. For a component of <a> that is false, the
+	/// corresponding component of x is returned. For a
+	/// component of a that is true, the corresponding
+	/// component of y is returned. Components of x and y that
+	/// are not selected are allowed to be invalid floating point
+	/// values and will have no effect on the results. Thus, this
+	/// provides different functionality than
+	/// genType mix(genType x, genType y, genType(a))
+	/// where a is a Boolean vector.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mix.xml">GLSL mix man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	/// 
+	/// @param[in]  x Value to interpolate.
+	/// @param[in]  y Value to interpolate.
+	/// @param[in]  a Interpolant.
+	/// 
+	/// @tparam	genTypeT Floating point scalar or vector.
+	/// @tparam genTypeU Floating point or boolean scalar or vector. It can't be a vector if it is the length of genTypeT.
+	/// 
+	/// @code
+	/// #include <glm/glm.hpp>
+	/// ...
+	/// float a;
+	/// bool b;
+	/// glm::dvec3 e;
+	/// glm::dvec3 f;
+	/// glm::vec4 g;
+	/// glm::vec4 h;
+	/// ...
+	/// glm::vec4 r = glm::mix(g, h, a); // Interpolate with a floating-point scalar two vectors. 
+	/// glm::vec4 s = glm::mix(g, h, b); // Teturns g or h;
+	/// glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second.
+	/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
+	/// @endcode
+	template <typename T, typename U, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> mix(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y,
+		vecType<U, P> const & a);
+
+	template <typename T, typename U, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> mix(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y,
+		U const & a);
+
+	template <typename genTypeT, typename genTypeU>
+	GLM_FUNC_DECL genTypeT mix(
+		genTypeT const & x,
+		genTypeT const & y,
+		genTypeU const & a);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType step(
+		genType const & edge,
+		genType const & x);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, typename T, precision P>
+	GLM_FUNC_DECL vecType<T, P> step(
+		T const & edge,
+		vecType<T, P> const & x);
+
+	/// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
+	/// performs smooth Hermite interpolation between 0 and 1
+	/// when edge0 < x < edge1. This is useful in cases where
+	/// you would want a threshold function with a smooth
+	/// transition. This is equivalent to:
+	/// genType t;
+	/// t = clamp ((x - edge0) / (edge1 - edge0), 0, 1);
+	/// return t * t * (3 - 2 * t);
+	/// Results are undefined if edge0 >= edge1.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType smoothstep(
+		genType const & edge0,
+		genType const & edge1,
+		genType const & x);
+
+	template <typename genType>
+	GLM_FUNC_DECL genType smoothstep(
+		typename genType::value_type const & edge0,
+		typename genType::value_type const & edge1,
+		genType const & x);
+
+	/// Returns true if x holds a NaN (not a number)
+	/// representation in the underlying implementation's set of
+	/// floating point representations. Returns false otherwise,
+	/// including for implementations with no NaN
+	/// representations.
+	/// 
+	/// /!\ When using compiler fast math, this function may fail.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType> 
+	GLM_FUNC_DECL typename genType::bool_type isnan(genType const & x);
+
+	/// Returns true if x holds a positive infinity or negative
+	/// infinity representation in the underlying implementation's
+	/// set of floating point representations. Returns false
+	/// otherwise, including for implementations with no infinity
+	/// representations.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType> 
+	GLM_FUNC_DECL typename genType::bool_type isinf(genType const & x);
+
+	/// Returns a signed integer value representing
+	/// the encoding of a floating-point value. The floating-point
+	/// value's bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL int floatBitsToInt(float const & v);
+
+	/// Returns a signed integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_DECL vecType<int, P> floatBitsToInt(vecType<float, P> const & v);
+
+	/// Returns a unsigned integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL uint floatBitsToUint(float const & v);
+
+	/// Returns a unsigned integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_DECL vecType<uint, P> floatBitsToUint(vecType<float, P> const & v);
+
+	/// Returns a floating-point value corresponding to a signed
+	/// integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL float intBitsToFloat(int const & v);
+
+	/// Returns a floating-point value corresponding to a signed
+	/// integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_DECL vecType<float, P> intBitsToFloat(vecType<int, P> const & v);
+
+	/// Returns a floating-point value corresponding to a
+	/// unsigned integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL float uintBitsToFloat(uint const & v);
+
+	/// Returns a floating-point value corresponding to a
+	/// unsigned integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_DECL vecType<float, P> uintBitsToFloat(vecType<uint, P> const & v);
+
+	/// Computes and returns a * b + c.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType fma(genType const & a, genType const & b, genType const & c);
+
+	/// Splits x into a floating-point significand in the range
+	/// [0.5, 1.0) and an integral exponent of two, such that:
+	/// x = significand * exp(2, exponent)
+	/// 
+	/// The significand is returned by the function and the
+	/// exponent is returned in the parameter exp. For a
+	/// floating-point value of zero, the significant and exponent
+	/// are both zero. For a floating-point value that is an
+	/// infinity or is not a number, the results are undefined.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType, typename genIType>
+	GLM_FUNC_DECL genType frexp(genType const & x, genIType & exp);
+
+	/// Builds a floating-point number from x and the
+	/// corresponding integral exponent of two in exp, returning:
+	/// significand * exp(2, exponent)
+	/// 
+	/// If this product is too large to be represented in the
+	/// floating-point type, the result is undefined.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///  
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>; 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType, typename genIType>
+	GLM_FUNC_DECL genType ldexp(genType const & x, genIType const & exp);
+
+	/// @}
+}//namespace glm
+
+#include "func_common.inl"
+

app/android/jni/third-party/include/glm/detail/func_exponential.hpp

@@ -0,0 +1,129 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/func_exponential.hpp
+/// @date 2008-08-08 / 2011-06-14
+/// @author Christophe Riccio
+/// 
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+///
+/// @defgroup core_func_exponential Exponential functions
+/// @ingroup core
+/// 
+/// These all operate component-wise. The description is per component.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "type_vec1.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include <cmath>
+
+namespace glm
+{
+	/// @addtogroup core_func_exponential
+	/// @{
+
+	/// Returns 'base' raised to the power 'exponent'. 
+	///
+	/// @param base Floating point value. pow function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @param exponent Floating point value representing the 'exponent'.
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	GLM_FUNC_DECL genType pow(genType const & base, genType const & exponent);
+
+	/// Returns the natural exponentiation of x, i.e., e^x.
+	///
+	/// @param x exp function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	GLM_FUNC_DECL genType exp(genType const & x);
+
+	/// Returns the natural logarithm of x, i.e., 
+	/// returns the value y which satisfies the equation x = e^y. 
+	/// Results are undefined if x <= 0.
+	///
+	/// @param x log function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	GLM_FUNC_DECL genType log(genType const & x);
+
+	/// Returns 2 raised to the x power.
+	/// 
+	/// @param x exp2 function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	GLM_FUNC_DECL genType exp2(genType const & x);
+
+	/// Returns the base 2 log of x, i.e., returns the value y, 
+	/// which satisfies the equation x = 2 ^ y.
+	/// 
+	/// @param x log2 function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType log2(genType x);
+
+	/// Returns the positive square root of x.
+	/// 
+	/// @param x sqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	//template <typename genType>
+	//GLM_FUNC_DECL genType sqrt(genType const & x);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> sqrt(vecType<T, P> const & x);
+	
+	/// Returns the reciprocal of the positive square root of x.
+	/// 
+	/// @param x inversesqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	GLM_FUNC_DECL genType inversesqrt(genType const & x);
+
+	/// @}
+}//namespace glm
+
+#include "func_exponential.inl"

app/android/jni/third-party/include/glm/detail/func_exponential.inl

@@ -0,0 +1,264 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/func_exponential.inl
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "func_vector_relational.hpp"
+#include "_vectorize.hpp"
+#include <limits>
+#include <cmath>
+#include <cassert>
+
+namespace glm{
+namespace detail
+{
+	template <bool isFloat>
+	struct compute_log2
+	{
+		template <typename T>
+		T operator() (T const & Value) const;
+	};
+
+	template <>
+	struct compute_log2<true>
+	{
+		template <typename T>
+		GLM_FUNC_QUALIFIER T operator() (T const & Value) const
+		{
+#			if(GLM_LANG & GLM_LANG_CXX11_FLAG & !ANDROID)
+				return std::log2(Value);
+#			else
+				return std::log(Value) * static_cast<T>(1.4426950408889634073599246810019);
+#			endif
+		}
+	};
+
+	template <template <class, precision> class vecType, typename T, precision P>
+	struct compute_inversesqrt
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		{
+			return static_cast<T>(1) / sqrt(x);
+		}
+	};
+		
+	template <template <class, precision> class vecType>
+	struct compute_inversesqrt<vecType, float, lowp>
+	{
+		GLM_FUNC_QUALIFIER static vecType<float, lowp> call(vecType<float, lowp> const & x)
+		{
+			vecType<float, lowp> tmp(x);
+			vecType<float, lowp> xhalf(tmp * 0.5f);
+			vecType<uint, lowp>* p = reinterpret_cast<vecType<uint, lowp>*>(const_cast<vecType<float, lowp>*>(&x));
+			vecType<uint, lowp> i = vecType<uint, lowp>(0x5f375a86) - (*p >> vecType<uint, lowp>(1));
+			vecType<float, lowp>* ptmp = reinterpret_cast<vecType<float, lowp>*>(&i);
+			tmp = *ptmp;
+			tmp = tmp * (1.5f - xhalf * tmp * tmp);
+			return tmp;
+		}
+	};
+}//namespace detail
+
+	// pow
+	using std::pow;
+
+/*
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType pow
+	(
+		genType const & x, 
+		genType const & y
+	)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genType>::is_iec559,
+			"'pow' only accept floating-point inputs");
+
+		return std::pow(x, y);
+	}
+*/
+
+	VECTORIZE_VEC_VEC(pow)
+
+	// exp
+	using std::exp;
+
+/*
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType exp
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genType>::is_iec559,
+			"'exp' only accept floating-point inputs");
+
+		return std::exp(x);
+	}
+*/
+
+	VECTORIZE_VEC(exp)
+
+	// log
+	using std::log;
+/*
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType log
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genType>::is_iec559,
+			"'log' only accept floating-point inputs");
+
+		return std::log(x);
+	}
+*/
+	VECTORIZE_VEC(log)
+
+	//exp2, ln2 = 0.69314718055994530941723212145818f
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType exp2(genType const & x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genType>::is_iec559,
+			"'exp2' only accept floating-point inputs");
+
+		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
+	}
+
+	VECTORIZE_VEC(exp2)
+
+	// log2, ln2 = 0.69314718055994530941723212145818f
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType log2(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer,
+			"GLM core 'log2' only accept floating-point inputs. Include <glm/gtx/integer.hpp> for additional integer support.");
+
+		assert(x > genType(0)); // log2 is only defined on the range (0, inf]
+		return detail::compute_log2<std::numeric_limits<genType>::is_iec559>()(x);
+	}
+
+	VECTORIZE_VEC(log2)
+
+	namespace detail
+	{
+		template <template <class, precision> class vecType, typename T, precision P>
+		struct compute_sqrt{};
+		
+		template <typename T, precision P>
+		struct compute_sqrt<detail::tvec1, T, P>
+		{
+			GLM_FUNC_QUALIFIER static detail::tvec1<T, P> call(detail::tvec1<T, P> const & x)
+			{
+				return detail::tvec1<T, P>(std::sqrt(x.x));
+			}
+		};
+		
+		template <typename T, precision P>
+		struct compute_sqrt<detail::tvec2, T, P>
+		{
+			GLM_FUNC_QUALIFIER static detail::tvec2<T, P> call(detail::tvec2<T, P> const & x)
+			{
+				return detail::tvec2<T, P>(std::sqrt(x.x), std::sqrt(x.y));
+			}
+		};
+		
+		template <typename T, precision P>
+		struct compute_sqrt<detail::tvec3, T, P>
+		{
+			GLM_FUNC_QUALIFIER static detail::tvec3<T, P> call(detail::tvec3<T, P> const & x)
+			{
+				return detail::tvec3<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z));
+			}
+		};
+		
+		template <typename T, precision P>
+		struct compute_sqrt<detail::tvec4, T, P>
+		{
+			GLM_FUNC_QUALIFIER static detail::tvec4<T, P> call(detail::tvec4<T, P> const & x)
+			{
+				return detail::tvec4<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z), std::sqrt(x.w));
+			}
+		};
+	}//namespace detail
+	
+	// sqrt
+	using std::sqrt;
+/*
+	GLM_FUNC_QUALIFIER float sqrt(float x)
+	{
+#		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
+			detail::tvec1<float, highp> tmp(detail::compute_sqrt<detail::tvec1, float, highp>::call(x));
+			return tmp.x;
+#		else
+			return detail::compute_sqrt<detail::tvec1, float, highp>::call(x).x;
+#		endif
+	}
+
+	GLM_FUNC_QUALIFIER double sqrt(double x)
+	{
+#		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
+			detail::tvec1<double, highp> tmp(detail::compute_sqrt<detail::tvec1, double, highp>::call(x));
+			return tmp.x;
+#		else
+			return detail::compute_sqrt<detail::tvec1, double, highp>::call(x).x;
+#		endif
+	}
+*/
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
+		return detail::compute_sqrt<vecType, T, P>::call(x);
+	}
+
+	// inversesqrt
+	GLM_FUNC_QUALIFIER float inversesqrt(float const & x)
+	{
+		return 1.0f / sqrt(x);
+	}
+	
+	GLM_FUNC_QUALIFIER double inversesqrt(double const & x)
+	{
+		return 1.0 / sqrt(x);
+	}
+	
+	template <template <class, precision> class vecType, typename T, precision P>
+	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt
+	(
+		vecType<T, P> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
+		return detail::compute_inversesqrt<vecType, T, P>::call(x);
+	}
+
+	VECTORIZE_VEC(inversesqrt)
+}//namespace glm

app/android/jni/third-party/include/glm/detail/func_geometric.hpp

@@ -0,0 +1,148 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/func_geometric.hpp
+/// @date 2008-08-03 / 2011-06-14
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+/// 
+/// @defgroup core_func_geometric Geometric functions
+/// @ingroup core
+/// 
+/// These operate on vectors as vectors, not component-wise.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_geometric
+	/// @{
+
+	/// Returns the length of x, i.e., sqrt(x * x).
+	/// 
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType> 
+	GLM_FUNC_DECL typename genType::value_type length(
+		genType const & x); 
+
+	/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType> 
+	GLM_FUNC_DECL typename genType::value_type distance(
+		genType const & p0, 
+		genType const & p1);
+
+	/// Returns the dot product of x and y, i.e., result = x * y.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL T dot(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y);
+
+	/// Returns the dot product of x and y, i.e., result = x * y.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType dot(
+		genType const & x,
+		genType const & y);
+
+	/// Returns the cross product of x and y.
+	///
+	/// @tparam valType Floating-point scalar types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename T, precision P>
+	GLM_FUNC_DECL detail::tvec3<T, P> cross(
+		detail::tvec3<T, P> const & x,
+		detail::tvec3<T, P> const & y);
+
+	/// Returns a vector in the same direction as x but with length of 1.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType normalize(
+		genType const & x);
+
+	/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType faceforward(
+		genType const & N,
+		genType const & I,
+		genType const & Nref);
+
+	/// For the incident vector I and surface orientation N, 
+	/// returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType reflect(
+		genType const & I,
+		genType const & N);
+
+	/// For the incident vector I and surface normal N, 
+	/// and the ratio of indices of refraction eta, 
+	/// return the refraction vector.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> refract(
+		vecType<T, P> const & I,
+		vecType<T, P> const & N,
+		T const & eta);
+
+	/// @}
+}//namespace glm
+
+#include "func_geometric.inl"

app/android/jni/third-party/include/glm/detail/func_geometric.inl

@@ -0,0 +1,339 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/func_geometric.inl
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "func_exponential.hpp"
+#include "func_common.hpp"
+#include "type_vec2.hpp"
+#include "type_vec4.hpp"
+#include "type_float.hpp"
+
+namespace glm{
+namespace detail
+{
+	template <template <class, precision> class vecType, typename T, precision P>
+	struct compute_dot{};
+
+	template <typename T, precision P>
+	struct compute_dot<detail::tvec1, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(detail::tvec1<T, P> const & x, detail::tvec1<T, P> const & y)
+		{
+#			ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
+				detail::tvec1<T, P> tmp(x * y);
+				return tmp.x;
+#			else
+				return detail::tvec1<T, P>(x * y).x;
+#			endif
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_dot<detail::tvec2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(detail::tvec2<T, P> const & x, detail::tvec2<T, P> const & y)
+		{
+			detail::tvec2<T, P> tmp(x * y);
+			return tmp.x + tmp.y;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_dot<detail::tvec3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(detail::tvec3<T, P> const & x, detail::tvec3<T, P> const & y)
+		{
+			detail::tvec3<T, P> tmp(x * y);
+			return tmp.x + tmp.y + tmp.z;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_dot<detail::tvec4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(detail::tvec4<T, P> const & x, detail::tvec4<T, P> const & y)
+		{
+			detail::tvec4<T, P> tmp(x * y);
+			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
+		}
+	};
+}//namespace detail
+
+	// length
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType length
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' only accept floating-point inputs");
+
+		return abs(x);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T length(detail::tvec2<T, P> const & v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
+
+		T sqr = v.x * v.x + v.y * v.y;
+		return sqrt(sqr);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T length(detail::tvec3<T, P> const & v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
+
+		T sqr = v.x * v.x + v.y * v.y + v.z * v.z;
+		return sqrt(sqr);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T length(detail::tvec4<T, P> const & v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
+
+		T sqr = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
+		return sqrt(sqr);
+	}
+
+	// distance
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType distance
+	(
+		genType const & p0,
+		genType const & p1
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T distance
+	(
+		detail::tvec2<T, P> const & p0,
+		detail::tvec2<T, P> const & p1
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T distance
+	(
+		detail::tvec3<T, P> const & p0,
+		detail::tvec3<T, P> const & p1
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T distance
+	(
+		detail::tvec4<T, P> const & p0,
+		detail::tvec4<T, P> const & p1
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+	}
+
+	// dot
+	template <typename T>
+	GLM_FUNC_QUALIFIER T dot
+	(
+		T const & x,
+		T const & y
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
+		return detail::compute_dot<detail::tvec1, T, highp>::call(x, y);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T dot
+	(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
+		return detail::compute_dot<vecType, T, P>::call(x, y);
+	}
+
+/* // SSE3
+	GLM_FUNC_QUALIFIER float dot(const tvec4<float>& x, const tvec4<float>& y)
+	{
+		float Result;
+		__asm
+		{
+			mov		esi, x
+			mov		edi, y
+			movaps	xmm0, [esi]
+			mulps	xmm0, [edi]
+			haddps(	_xmm0, _xmm0 )
+			haddps(	_xmm0, _xmm0 )
+			movss	Result, xmm0
+		}
+		return Result;
+	}
+*/
+	// cross
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> cross
+	(
+		detail::tvec3<T, P> const & x,
+		detail::tvec3<T, P> const & y
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' only accept floating-point inputs");
+
+		return detail::tvec3<T, P>(
+			x.y * y.z - y.y * x.z,
+			x.z * y.x - y.z * x.x,
+			x.x * y.y - y.x * x.y);
+	}
+
+	// normalize
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType normalize
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' only accept floating-point inputs");
+
+		return x < genType(0) ? genType(-1) : genType(1);
+	}
+
+	// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> normalize
+	(
+		detail::tvec2<T, P> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
+		
+		T sqr = x.x * x.x + x.y * x.y;
+		return x * inversesqrt(sqr);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> normalize
+	(
+		detail::tvec3<T, P> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
+
+		T sqr = x.x * x.x + x.y * x.y + x.z * x.z;
+		return x * inversesqrt(sqr);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> normalize
+	(
+		detail::tvec4<T, P> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
+		
+		T sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
+		return x * inversesqrt(sqr);
+	}
+
+	// faceforward
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType faceforward
+	(
+		genType const & N,
+		genType const & I,
+		genType const & Nref
+	)
+	{
+		return dot(Nref, I) < 0 ? N : -N;
+	}
+
+	// reflect
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType reflect
+	(
+		genType const & I,
+		genType const & N
+	)
+	{
+		return I - N * dot(N, I) * genType(2);
+	}
+
+	// refract
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType refract
+	(
+		genType const & I,
+		genType const & N,
+		genType const & eta
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' only accept floating-point inputs");
+
+		genType dotValue = dot(N, I);
+		genType k = genType(1) - eta * eta * (genType(1) - dotValue * dotValue);
+		if(k < genType(0))
+			return genType(0);
+		else
+			return eta * I - (eta * dotValue + sqrt(k)) * N;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> refract
+	(
+		vecType<T, P> const & I,
+		vecType<T, P> const & N,
+		T const & eta
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' only accept floating-point inputs");
+
+		T dotValue = dot(N, I);
+		T k = T(1) - eta * eta * (T(1) - dotValue * dotValue);
+		if(k < T(0))
+			return vecType<T, P>(0);
+		else
+			return eta * I - (eta * dotValue + std::sqrt(k)) * N;
+	}
+
+}//namespace glm

app/android/jni/third-party/include/glm/detail/func_integer.hpp

@@ -0,0 +1,199 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/func_integer.hpp
+/// @date 2010-03-17 / 2011-06-18
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+/// 
+/// @defgroup core_func_integer Integer functions
+/// @ingroup core
+/// 
+/// These all operate component-wise. The description is per component. 
+/// The notation [a, b] means the set of bits from bit-number a through bit-number 
+/// b, inclusive. The lowest-order bit is bit 0.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_integer
+	/// @{
+
+	/// Adds 32-bit unsigned integer x and y, returning the sum
+	/// modulo pow(2, 32). The value carry is set to 0 if the sum was
+	/// less than pow(2, 32), or to 1 otherwise.
+	///
+	/// @tparam genUType Unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genUType>
+	GLM_FUNC_DECL genUType uaddCarry(
+		genUType const & x,
+		genUType const & y,
+		genUType & carry);
+
+	/// Subtracts the 32-bit unsigned integer y from x, returning
+	/// the difference if non-negative, or pow(2, 32) plus the difference
+	/// otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise.
+	///
+	/// @tparam genUType Unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genUType>
+	GLM_FUNC_DECL genUType usubBorrow(
+		genUType const & x,
+		genUType const & y,
+		genUType & borrow);
+		
+	/// Multiplies 32-bit integers x and y, producing a 64-bit
+	/// result. The 32 least-significant bits are returned in lsb.
+	/// The 32 most-significant bits are returned in msb.
+	///
+	/// @tparam genUType Unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genUType>
+	GLM_FUNC_DECL void umulExtended(
+		genUType const & x,
+		genUType const & y,
+		genUType & msb,
+		genUType & lsb);
+		
+	/// Multiplies 32-bit integers x and y, producing a 64-bit
+	/// result. The 32 least-significant bits are returned in lsb.
+	/// The 32 most-significant bits are returned in msb.
+	/// 
+	/// @tparam genIType Signed integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIType>
+	GLM_FUNC_DECL void imulExtended(
+		genIType const & x,
+		genIType const & y,
+		genIType & msb,
+		genIType & lsb);
+
+	/// Extracts bits [offset, offset + bits - 1] from value,
+	/// returning them in the least significant bits of the result.
+	/// For unsigned data types, the most significant bits of the
+	/// result will be set to zero. For signed data types, the
+	/// most significant bits will be set to the value of bit offset + base - 1.
+	///
+	/// If bits is zero, the result will be zero. The result will be
+	/// undefined if offset or bits is negative, or if the sum of
+	/// offset and bits is greater than the number of bits used
+	/// to store the operand.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	GLM_FUNC_DECL genIUType bitfieldExtract(
+		genIUType const & Value,
+		int const & Offset,
+		int const & Bits);
+
+	/// Returns the insertion the bits least-significant bits of insert into base.
+	///
+	/// The result will have bits [offset, offset + bits - 1] taken
+	/// from bits [0, bits - 1] of insert, and all other bits taken
+	/// directly from the corresponding bits of base. If bits is
+	/// zero, the result will simply be base. The result will be
+	/// undefined if offset or bits is negative, or if the sum of
+	/// offset and bits is greater than the number of bits used to
+	/// store the operand.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	GLM_FUNC_DECL genIUType bitfieldInsert(
+		genIUType const & Base,
+		genIUType const & Insert,
+		int const & Offset,
+		int const & Bits);
+
+	/// Returns the reversal of the bits of value. 
+	/// The bit numbered n of the result will be taken from bit (bits - 1) - n of value, 
+	/// where bits is the total number of bits used to represent value.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	GLM_FUNC_DECL genIUType bitfieldReverse(genIUType const & Value);
+		
+	/// Returns the number of bits set to 1 in the binary representation of value.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	///
+	/// @todo Clarify the declaration to specify that scalars are suported.
+	template <typename T, template <typename> class genIUType>
+	GLM_FUNC_DECL typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
+
+	/// Returns the bit number of the least significant bit set to
+	/// 1 in the binary representation of value. 
+	/// If value is zero, -1 will be returned.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	///
+	/// @todo Clarify the declaration to specify that scalars are suported.
+	template <typename T, template <typename> class genIUType>
+	GLM_FUNC_DECL typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
+
+	/// Returns the bit number of the most significant bit in the binary representation of value.
+	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
+	/// For negative integers, the result will be the bit number of the most significant
+	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	///
+	/// @todo Clarify the declaration to specify that scalars are suported.
+	template <typename T, template <typename> class genIUType>
+	GLM_FUNC_DECL typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
+
+	/// @}
+}//namespace glm
+
+#include "func_integer.inl"

app/android/jni/third-party/include/glm/detail/func_integer.inl

@@ -0,0 +1,654 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/func_integer.inl
+/// @date 2010-03-17 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include "type_int.hpp"
+#include "_vectorize.hpp"
+#if(GLM_ARCH != GLM_ARCH_PURE)
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+#	include <intrin.h>
+#	pragma intrinsic(_BitScanReverse)
+#endif//(GLM_COMPILER & GLM_COMPILER_VC)
+#endif//(GLM_ARCH != GLM_ARCH_PURE)
+#include <limits>
+
+namespace glm
+{
+	// uaddCarry
+	template <>
+	GLM_FUNC_QUALIFIER uint uaddCarry
+	(
+		uint const & x,
+		uint const & y,
+		uint & Carry
+	)
+	{
+		uint64 Value64 = static_cast<uint64>(x) + static_cast<uint64>(y);
+		uint32 Result = static_cast<uint32>(Value64 % (static_cast<uint64>(1) << static_cast<uint64>(32)));
+		Carry = (Value64 % (static_cast<uint64>(1) << static_cast<uint64>(32))) > 1 ? static_cast<uint32>(1) : static_cast<uint32>(0);
+		return Result;
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER uvec2 uaddCarry
+	(
+		uvec2 const & x,
+		uvec2 const & y,
+		uvec2 & Carry
+	)
+	{
+		return uvec2(
+			uaddCarry(x[0], y[0], Carry[0]),
+			uaddCarry(x[1], y[1], Carry[1]));
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER uvec3 uaddCarry
+	(
+		uvec3 const & x,
+		uvec3 const & y,
+		uvec3 & Carry
+	)
+	{
+		return uvec3(
+			uaddCarry(x[0], y[0], Carry[0]),
+			uaddCarry(x[1], y[1], Carry[1]),
+			uaddCarry(x[2], y[2], Carry[2]));
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER uvec4 uaddCarry
+	(
+		uvec4 const & x,
+		uvec4 const & y,
+		uvec4 & Carry
+	)
+	{
+		return uvec4(
+			uaddCarry(x[0], y[0], Carry[0]),
+			uaddCarry(x[1], y[1], Carry[1]),
+			uaddCarry(x[2], y[2], Carry[2]),
+			uaddCarry(x[3], y[3], Carry[3]));
+	}
+
+	// usubBorrow
+	template <>
+	GLM_FUNC_QUALIFIER uint usubBorrow
+	(
+		uint const & x,
+		uint const & y,
+		uint & Borrow
+	)
+	{
+		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
+
+		Borrow = x >= y ? static_cast<uint32>(0) : static_cast<uint32>(1);
+		if(y >= x)
+			return y - x;
+		else
+			return static_cast<uint32>((static_cast<int64>(1) << static_cast<int64>(32)) + (static_cast<int64>(y) - static_cast<int64>(x)));
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER uvec2 usubBorrow
+	(
+		uvec2 const & x,
+		uvec2 const & y,
+		uvec2 & Borrow
+	)
+	{
+		return uvec2(
+			usubBorrow(x[0], y[0], Borrow[0]),
+			usubBorrow(x[1], y[1], Borrow[1]));
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER uvec3 usubBorrow
+	(
+		uvec3 const & x,
+		uvec3 const & y,
+		uvec3 & Borrow
+	)
+	{
+		return uvec3(
+			usubBorrow(x[0], y[0], Borrow[0]),
+			usubBorrow(x[1], y[1], Borrow[1]),
+			usubBorrow(x[2], y[2], Borrow[2]));
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER uvec4 usubBorrow
+	(
+		uvec4 const & x,
+		uvec4 const & y,
+		uvec4 & Borrow
+	)
+	{
+		return uvec4(
+			usubBorrow(x[0], y[0], Borrow[0]),
+			usubBorrow(x[1], y[1], Borrow[1]),
+			usubBorrow(x[2], y[2], Borrow[2]),
+			usubBorrow(x[3], y[3], Borrow[3]));
+	}
+
+	// umulExtended
+	template <>
+	GLM_FUNC_QUALIFIER void umulExtended
+	(
+		uint const & x,
+		uint const & y,
+		uint & msb,
+		uint & lsb
+	)
+	{
+		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
+
+		uint64 Value64 = static_cast<uint64>(x) * static_cast<uint64>(y);
+		uint32* PointerMSB = (reinterpret_cast<uint32*>(&Value64) + 1);
+		msb = *PointerMSB;
+		uint32* PointerLSB = (reinterpret_cast<uint32*>(&Value64) + 0);
+		lsb = *PointerLSB;
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER void umulExtended
+	(
+		uvec2 const & x,
+		uvec2 const & y,
+		uvec2 & msb,
+		uvec2 & lsb
+	)
+	{
+		umulExtended(x[0], y[0], msb[0], lsb[0]);
+		umulExtended(x[1], y[1], msb[1], lsb[1]);
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER void umulExtended
+	(
+		uvec3 const & x,
+		uvec3 const & y,
+		uvec3 & msb,
+		uvec3 & lsb
+	)
+	{
+		umulExtended(x[0], y[0], msb[0], lsb[0]);
+		umulExtended(x[1], y[1], msb[1], lsb[1]);
+		umulExtended(x[2], y[2], msb[2], lsb[2]);
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER void umulExtended
+	(
+		uvec4 const & x,
+		uvec4 const & y,
+		uvec4 & msb,
+		uvec4 & lsb
+	)
+	{
+		umulExtended(x[0], y[0], msb[0], lsb[0]);
+		umulExtended(x[1], y[1], msb[1], lsb[1]);
+		umulExtended(x[2], y[2], msb[2], lsb[2]);
+		umulExtended(x[3], y[3], msb[3], lsb[3]);
+	}
+
+	// imulExtended
+	template <>
+	GLM_FUNC_QUALIFIER void imulExtended
+	(
+		int const & x,
+		int const & y,
+		int & msb,
+		int & lsb
+	)
+	{
+		GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
+
+		int64 Value64 = static_cast<int64>(x) * static_cast<int64>(y);
+		int32* PointerMSB = (reinterpret_cast<int32*>(&Value64) + 1);
+		msb = *PointerMSB;
+		int32* PointerLSB = (reinterpret_cast<int32*>(&Value64));
+		lsb = *PointerLSB;
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER void imulExtended
+	(
+		ivec2 const & x,
+		ivec2 const & y,
+		ivec2 & msb,
+		ivec2 & lsb
+	)
+	{
+		imulExtended(x[0], y[0], msb[0], lsb[0]),
+		imulExtended(x[1], y[1], msb[1], lsb[1]);
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER void imulExtended
+	(
+		ivec3 const & x,
+		ivec3 const & y,
+		ivec3 & msb,
+		ivec3 & lsb
+	)
+	{
+		imulExtended(x[0], y[0], msb[0], lsb[0]),
+		imulExtended(x[1], y[1], msb[1], lsb[1]);
+		imulExtended(x[2], y[2], msb[2], lsb[2]);
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER void imulExtended
+	(
+		ivec4 const & x,
+		ivec4 const & y,
+		ivec4 & msb,
+		ivec4 & lsb
+	)
+	{
+		imulExtended(x[0], y[0], msb[0], lsb[0]),
+		imulExtended(x[1], y[1], msb[1], lsb[1]);
+		imulExtended(x[2], y[2], msb[2], lsb[2]);
+		imulExtended(x[3], y[3], msb[3], lsb[3]);
+	}
+
+	// bitfieldExtract
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldExtract
+	(
+		genIUType const & Value,
+		int const & Offset,
+		int const & Bits
+	)
+	{
+		int GenSize = int(sizeof(genIUType)) << int(3);
+
+		assert(Offset + Bits <= GenSize);
+
+		genIUType ShiftLeft = Bits ? Value << (GenSize - (Bits + Offset)) : genIUType(0);
+		genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Bits);
+
+		return ShiftBack;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitfieldExtract
+	(
+		detail::tvec2<T, P> const & Value,
+		int const & Offset,
+		int const & Bits
+	)
+	{
+		return detail::tvec2<T, P>(
+			bitfieldExtract(Value[0], Offset, Bits),
+			bitfieldExtract(Value[1], Offset, Bits));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitfieldExtract
+	(
+		detail::tvec3<T, P> const & Value,
+		int const & Offset,
+		int const & Bits
+	)
+	{
+		return detail::tvec3<T, P>(
+			bitfieldExtract(Value[0], Offset, Bits),
+			bitfieldExtract(Value[1], Offset, Bits),
+			bitfieldExtract(Value[2], Offset, Bits));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitfieldExtract
+	(
+		detail::tvec4<T, P> const & Value,
+		int const & Offset,
+		int const & Bits
+	)
+	{
+		return detail::tvec4<T, P>(
+			bitfieldExtract(Value[0], Offset, Bits),
+			bitfieldExtract(Value[1], Offset, Bits),
+			bitfieldExtract(Value[2], Offset, Bits),
+			bitfieldExtract(Value[3], Offset, Bits));
+	}
+
+	// bitfieldInsert
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldInsert
+	(
+		genIUType const & Base,
+		genIUType const & Insert,
+		int const & Offset,
+		int const & Bits
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
+		assert(Offset + Bits <= sizeof(genIUType));
+
+		if(Bits == 0)
+			return Base;
+
+		genIUType Mask = 0;
+		for(int Bit = Offset; Bit < Offset + Bits; ++Bit)
+			Mask |= (1 << Bit);
+
+		return (Base & ~Mask) | (Insert & Mask);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitfieldInsert
+	(
+		detail::tvec2<T, P> const & Base,
+		detail::tvec2<T, P> const & Insert,
+		int const & Offset,
+		int const & Bits
+	)
+	{
+		return detail::tvec2<T, P>(
+			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
+			bitfieldInsert(Base[1], Insert[1], Offset, Bits));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitfieldInsert
+	(
+		detail::tvec3<T, P> const & Base,
+		detail::tvec3<T, P> const & Insert,
+		int const & Offset,
+		int const & Bits
+	)
+	{
+		return detail::tvec3<T, P>(
+			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
+			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
+			bitfieldInsert(Base[2], Insert[2], Offset, Bits));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitfieldInsert
+	(
+		detail::tvec4<T, P> const & Base,
+		detail::tvec4<T, P> const & Insert,
+		int const & Offset,
+		int const & Bits
+	)
+	{
+		return detail::tvec4<T, P>(
+			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
+			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
+			bitfieldInsert(Base[2], Insert[2], Offset, Bits),
+			bitfieldInsert(Base[3], Insert[3], Offset, Bits));
+	}
+
+	// bitfieldReverse
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
+
+		genIUType Out = 0;
+		std::size_t BitSize = sizeof(genIUType) * 8;
+		for(std::size_t i = 0; i < BitSize; ++i)
+			if(Value & (genIUType(1) << i))
+				Out |= genIUType(1) << (BitSize - 1 - i);
+		return Out;
+	}	
+
+	VECTORIZE_VEC(bitfieldReverse)
+
+	// bitCount
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
+
+		int Count = 0;
+		for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
+		{
+			if(Value & (1 << i))
+				++Count;
+		}
+		return Count;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<int, P> bitCount
+	(
+		detail::tvec2<T, P> const & value
+	)
+	{
+		return detail::tvec2<int, P>(
+			bitCount(value[0]),
+			bitCount(value[1]));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<int, P> bitCount
+	(
+		detail::tvec3<T, P> const & value
+	)
+	{
+		return detail::tvec3<int, P>(
+			bitCount(value[0]),
+			bitCount(value[1]),
+			bitCount(value[2]));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<int, P> bitCount
+	(
+		detail::tvec4<T, P> const & value
+	)
+	{
+		return detail::tvec4<int, P>(
+			bitCount(value[0]),
+			bitCount(value[1]),
+			bitCount(value[2]),
+			bitCount(value[3]));
+	}
+
+	// findLSB
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER int findLSB
+	(
+		genIUType const & Value
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
+		if(Value == 0)
+			return -1;
+
+		genIUType Bit;
+		for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
+		return Bit;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<int, P> findLSB
+	(
+		detail::tvec2<T, P> const & value
+	)
+	{
+		return detail::tvec2<int, P>(
+			findLSB(value[0]),
+			findLSB(value[1]));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<int, P> findLSB
+	(
+		detail::tvec3<T, P> const & value
+	)
+	{
+		return detail::tvec3<int, P>(
+			findLSB(value[0]),
+			findLSB(value[1]),
+			findLSB(value[2]));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<int, P> findLSB
+	(
+		detail::tvec4<T, P> const & value
+	)
+	{
+		return detail::tvec4<int, P>(
+			findLSB(value[0]),
+			findLSB(value[1]),
+			findLSB(value[2]),
+			findLSB(value[3]));
+	}
+
+	// findMSB
+#if((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_VC))
+
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER int findMSB
+	(
+		genIUType const & Value
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+		if(Value == 0)
+			return -1;
+
+		unsigned long Result(0);
+		_BitScanReverse(&Result, Value);
+		return int(Result);
+	}
+/*
+// __builtin_clz seems to be buggy as it crasks for some values, from 0x00200000 to 80000000
+#elif((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC40))
+
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER int findMSB
+	(
+		genIUType const & Value
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+		if(Value == 0)
+			return -1;
+
+		// clz returns the number or trailing 0-bits; see
+		// http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Other-Builtins.html
+		//
+		// NoteBecause __builtin_clz only works for unsigned ints, this
+		// implementation will not work for 64-bit integers.
+		//
+		return 31 - __builtin_clzl(Value);
+	}
+*/
+#else
+
+/* SSE implementation idea
+
+		__m128i const Zero = _mm_set_epi32( 0,  0,  0,  0);
+		__m128i const One = _mm_set_epi32( 1,  1,  1,  1);
+		__m128i Bit = _mm_set_epi32(-1, -1, -1, -1);
+		__m128i Tmp = _mm_set_epi32(Value, Value, Value, Value);
+		__m128i Mmi = Zero;
+		for(int i = 0; i < 32; ++i)
+		{
+			__m128i Shilt = _mm_and_si128(_mm_cmpgt_epi32(Tmp, One), One);
+			Tmp = _mm_srai_epi32(Tmp, One);
+			Bit = _mm_add_epi32(Bit, _mm_and_si128(Shilt, i));
+			Mmi = _mm_and_si128(Mmi, One);
+		}
+		return Bit;
+
+*/
+
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER int findMSB
+	(
+		genIUType const & Value
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+		
+		if(Value == genIUType(0) || Value == genIUType(-1))
+			return -1;
+		else if(Value > 0)
+		{
+			genIUType Bit = genIUType(-1);
+			for(genIUType tmp = Value; tmp > 0; tmp >>= 1, ++Bit){}
+			return Bit;
+		}
+		else //if(Value < 0)
+		{
+			int const BitCount(sizeof(genIUType) * 8);
+			int MostSignificantBit(-1);
+			for(int BitIndex(0); BitIndex < BitCount; ++BitIndex)
+				MostSignificantBit = (Value & (1 << BitIndex)) ? MostSignificantBit : BitIndex;
+			assert(MostSignificantBit >= 0);
+			return MostSignificantBit;
+		}
+	}
+#endif//(GLM_COMPILER)
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<int, P> findMSB
+	(
+		detail::tvec2<T, P> const & value
+	)
+	{
+		return detail::tvec2<int, P>(
+			findMSB(value[0]),
+			findMSB(value[1]));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<int, P> findMSB
+	(
+		detail::tvec3<T, P> const & value
+	)
+	{
+		return detail::tvec3<int, P>(
+			findMSB(value[0]),
+			findMSB(value[1]),
+			findMSB(value[2]));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<int, P> findMSB
+	(
+		detail::tvec4<T, P> const & value
+	)
+	{
+		return detail::tvec4<int, P>(
+			findMSB(value[0]),
+			findMSB(value[1]),
+			findMSB(value[2]),
+			findMSB(value[3]));
+	}
+}//namespace glm

app/android/jni/third-party/include/glm/detail/func_matrix.hpp

@@ -0,0 +1,176 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/func_matrix.hpp
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+/// 
+/// @defgroup core_func_matrix Matrix functions
+/// @ingroup core
+/// 
+/// For each of the following built-in matrix functions, there is both a 
+/// single-precision floating point version, where all arguments and return values 
+/// are single precision, and a double-precision floating version, where all 
+/// arguments and return values are double precision. Only the single-precision 
+/// floating point version is shown.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+// Dependencies
+#include "../detail/precision.hpp"
+#include "../detail/setup.hpp"
+#include "../detail/type_mat.hpp"
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../mat2x2.hpp"
+#include "../mat2x3.hpp"
+#include "../mat2x4.hpp"
+#include "../mat3x2.hpp"
+#include "../mat3x3.hpp"
+#include "../mat3x4.hpp"
+#include "../mat4x2.hpp"
+#include "../mat4x3.hpp"
+#include "../mat4x4.hpp"
+
+namespace glm{
+namespace detail
+{
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec2, tvec2>
+	{
+		typedef tmat2x2<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec2, tvec3>
+	{
+		typedef tmat2x3<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec2, tvec4>
+	{
+		typedef tmat2x4<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec3, tvec2>
+	{
+		typedef tmat3x2<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec3, tvec3>
+	{
+		typedef tmat3x3<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec3, tvec4>
+	{
+		typedef tmat3x4<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec4, tvec2>
+	{
+		typedef tmat4x2<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec4, tvec3>
+	{
+		typedef tmat4x3<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec4, tvec4>
+	{
+		typedef tmat4x4<T, P> type;
+	};
+
+}//namespace detail
+
+	/// @addtogroup core_func_matrix
+	/// @{
+
+	/// Multiply matrix x by matrix y component-wise, i.e., 
+	/// result[i][j] is the scalar product of x[i][j] and y[i][j].
+	/// 
+	/// @tparam matType Floating-point matrix types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_DECL matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y);
+
+	/// Treats the first parameter c as a column vector
+	/// and the second parameter r as a row vector
+	/// and does a linear algebraic matrix multiply c * r.
+	/// 
+	/// @tparam matType Floating-point matrix types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/outerProduct.xml">GLSL outerProduct man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	/// 
+	/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
+	template <typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
+	GLM_FUNC_DECL typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r);
+
+	/// Returns the transposed matrix of x
+	/// 
+	/// @tparam matType Floating-point matrix types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+#	if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11))
+		template <typename T, precision P, template <typename, precision> class matType>
+		GLM_FUNC_DECL typename matType<T, P>::transpose_type transpose(matType<T, P> const & x);
+#	endif
+	
+	/// Return the determinant of a squared matrix.
+	/// 
+	/// @tparam valType Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_DECL T determinant(matType<T, P> const & m);
+
+	/// Return the inverse of a squared matrix.
+	/// 
+	/// @tparam valType Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	 
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_DECL matType<T, P> inverse(matType<T, P> const & m);
+
+	/// @}
+}//namespace glm
+
+#include "func_matrix.inl"

app/android/jni/third-party/include/glm/detail/func_matrix.inl

@@ -0,0 +1,460 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/func_matrix.inl
+/// @date 2008-03-08 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "../geometric.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template
+	<
+		template <class, precision> class vecTypeA,
+		template <class, precision> class vecTypeB,
+		typename T, precision P
+	>
+	struct compute_outerProduct{};
+
+	template <typename T, precision P>
+	struct compute_outerProduct<detail::tvec2, detail::tvec2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec2>::type call(detail::tvec2<T, P> const & c, detail::tvec2<T, P> const & r)
+		{
+			detail::tmat2x2<T, P> m(detail::tmat2x2<T, P>::_null);
+			m[0][0] = c[0] * r[0];
+			m[0][1] = c[1] * r[0];
+			m[1][0] = c[0] * r[1];
+			m[1][1] = c[1] * r[1];
+			return m;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_outerProduct<detail::tvec3, detail::tvec3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec3>::type call(detail::tvec3<T, P> const & c, detail::tvec3<T, P> const & r)
+		{
+			detail::tmat3x3<T, P> m(detail::tmat3x3<T, P>::_null);
+			for(length_t i(0); i < m.length(); ++i)
+				m[i] = c * r[i];
+			return m;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_outerProduct<detail::tvec4, detail::tvec4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec4>::type call(detail::tvec4<T, P> const & c, detail::tvec4<T, P> const & r)
+		{
+			detail::tmat4x4<T, P> m(detail::tmat4x4<T, P>::_null);
+			for(length_t i(0); i < m.length(); ++i)
+				m[i] = c * r[i];
+			return m;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_outerProduct<detail::tvec3, detail::tvec2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec2>::type call(detail::tvec3<T, P> const & c, detail::tvec2<T, P> const & r)
+		{
+			detail::tmat2x3<T, P> m(detail::tmat2x3<T, P>::_null);
+			m[0][0] = c.x * r.x;
+			m[0][1] = c.y * r.x;
+			m[0][2] = c.z * r.x;
+			m[1][0] = c.x * r.y;
+			m[1][1] = c.y * r.y;
+			m[1][2] = c.z * r.y;
+			return m;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_outerProduct<detail::tvec2, detail::tvec3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec3>::type call(detail::tvec2<T, P> const & c, detail::tvec3<T, P> const & r)
+		{
+			detail::tmat3x2<T, P> m(detail::tmat3x2<T, P>::_null);
+			m[0][0] = c.x * r.x;
+			m[0][1] = c.y * r.x;
+			m[1][0] = c.x * r.y;
+			m[1][1] = c.y * r.y;
+			m[2][0] = c.x * r.z;
+			m[2][1] = c.y * r.z;
+			return m;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_outerProduct<detail::tvec4, detail::tvec2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec2>::type call(detail::tvec4<T, P> const & c, detail::tvec2<T, P> const & r)
+		{
+			detail::tmat2x4<T, P> m(detail::tmat2x4<T, P>::_null);
+			m[0][0] = c.x * r.x;
+			m[0][1] = c.y * r.x;
+			m[0][2] = c.z * r.x;
+			m[0][3] = c.w * r.x;
+			m[1][0] = c.x * r.y;
+			m[1][1] = c.y * r.y;
+			m[1][2] = c.z * r.y;
+			m[1][3] = c.w * r.y;
+			return m;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_outerProduct<detail::tvec2, detail::tvec4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec4>::type call(detail::tvec2<T, P> const & c, detail::tvec4<T, P> const & r)
+		{
+			detail::tmat4x2<T, P> m(detail::tmat4x2<T, P>::_null);
+			m[0][0] = c.x * r.x;
+			m[0][1] = c.y * r.x;
+			m[1][0] = c.x * r.y;
+			m[1][1] = c.y * r.y;
+			m[2][0] = c.x * r.z;
+			m[2][1] = c.y * r.z;
+			m[3][0] = c.x * r.w;
+			m[3][1] = c.y * r.w;
+			return m;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_outerProduct<detail::tvec4, detail::tvec3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec3>::type call(detail::tvec4<T, P> const & c, detail::tvec3<T, P> const & r)
+		{
+			detail::tmat3x4<T, P> m(detail::tmat3x4<T, P>::_null);
+			m[0][0] = c.x * r.x;
+			m[0][1] = c.y * r.x;
+			m[0][2] = c.z * r.x;
+			m[0][3] = c.w * r.x;
+			m[1][0] = c.x * r.y;
+			m[1][1] = c.y * r.y;
+			m[1][2] = c.z * r.y;
+			m[1][3] = c.w * r.y;
+			m[2][0] = c.x * r.z;
+			m[2][1] = c.y * r.z;
+			m[2][2] = c.z * r.z;
+			m[2][3] = c.w * r.z;
+			return m;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_outerProduct<detail::tvec3, detail::tvec4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec4>::type call(detail::tvec3<T, P> const & c, detail::tvec4<T, P> const & r)
+		{
+			detail::tmat4x3<T, P> m(detail::tmat4x3<T, P>::_null);
+			m[0][0] = c.x * r.x;
+			m[0][1] = c.y * r.x;
+			m[0][2] = c.z * r.x;
+			m[1][0] = c.x * r.y;
+			m[1][1] = c.y * r.y;
+			m[1][2] = c.z * r.y;
+			m[2][0] = c.x * r.z;
+			m[2][1] = c.y * r.z;
+			m[2][2] = c.z * r.z;
+			m[3][0] = c.x * r.w;
+			m[3][1] = c.y * r.w;
+			m[3][2] = c.z * r.w;
+			return m;
+		}
+	};
+
+	template <template <class, precision> class matType, typename T, precision P>
+	struct compute_transpose{};
+
+	template <typename T, precision P>
+	struct compute_transpose<detail::tmat2x2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static detail::tmat2x2<T, P> call(detail::tmat2x2<T, P> const & m)
+		{
+			detail::tmat2x2<T, P> result(detail::tmat2x2<T, P>::_null);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<detail::tmat2x3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static detail::tmat3x2<T, P> call(detail::tmat2x3<T, P> const & m)
+		{
+			detail::tmat3x2<T, P> result(detail::tmat3x2<T, P>::_null);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<detail::tmat2x4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static detail::tmat4x2<T, P> call(detail::tmat2x4<T, P> const & m)
+		{
+			detail::tmat4x2<T, P> result(detail::tmat4x2<T, P>::_null);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			result[3][0] = m[0][3];
+			result[3][1] = m[1][3];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<detail::tmat3x2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static detail::tmat2x3<T, P> call(detail::tmat3x2<T, P> const & m)
+		{
+			detail::tmat2x3<T, P> result(detail::tmat2x3<T, P>::_null);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<detail::tmat3x3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static detail::tmat3x3<T, P> call(detail::tmat3x3<T, P> const & m)
+		{
+			detail::tmat3x3<T, P> result(detail::tmat3x3<T, P>::_null);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			result[2][2] = m[2][2];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<detail::tmat3x4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static detail::tmat4x3<T, P> call(detail::tmat3x4<T, P> const & m)
+		{
+			detail::tmat4x3<T, P> result(detail::tmat4x3<T, P>::_null);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			result[2][2] = m[2][2];
+			result[3][0] = m[0][3];
+			result[3][1] = m[1][3];
+			result[3][2] = m[2][3];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<detail::tmat4x2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static detail::tmat2x4<T, P> call(detail::tmat4x2<T, P> const & m)
+		{
+			detail::tmat2x4<T, P> result(detail::tmat2x4<T, P>::_null);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+			result[0][3] = m[3][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+			result[1][3] = m[3][1];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<detail::tmat4x3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static detail::tmat3x4<T, P> call(detail::tmat4x3<T, P> const & m)
+		{
+			detail::tmat3x4<T, P> result(detail::tmat3x4<T, P>::_null);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+			result[0][3] = m[3][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+			result[1][3] = m[3][1];
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			result[2][2] = m[2][2];
+			result[2][3] = m[3][2];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<detail::tmat4x4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static detail::tmat4x4<T, P> call(detail::tmat4x4<T, P> const & m)
+		{
+			detail::tmat4x4<T, P> result(detail::tmat4x4<T, P>::_null);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+			result[0][3] = m[3][0];
+
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+			result[1][3] = m[3][1];
+
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			result[2][2] = m[2][2];
+			result[2][3] = m[3][2];
+
+			result[3][0] = m[0][3];
+			result[3][1] = m[1][3];
+			result[3][2] = m[2][3];
+			result[3][3] = m[3][3];
+			return result;
+		}
+	};
+
+	template <template <class, precision> class matType, typename T, precision P>
+	struct compute_determinant{};
+
+	template <typename T, precision P>
+	struct compute_determinant<detail::tmat2x2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(detail::tmat2x2<T, P> const & m)
+		{
+			return m[0][0] * m[1][1] - m[1][0] * m[0][1];
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_determinant<detail::tmat3x3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(detail::tmat3x3<T, P> const & m)
+		{
+			return
+				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+				- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+				+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_determinant<detail::tmat4x4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(detail::tmat4x4<T, P> const & m)
+		{
+			T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+
+			detail::tvec4<T, P> DetCof(
+				+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
+				- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+				+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
+				- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
+
+			return
+				m[0][0] * DetCof[0] + m[0][1] * DetCof[1] +
+				m[0][2] * DetCof[2] + m[0][3] * DetCof[3];
+		}
+	};
+}//namespace detail
+
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_QUALIFIER matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'matrixCompMult' only accept floating-point inputs");
+
+		matType<T, P> result(matType<T, P>::_null);
+		for(length_t i = 0; i < result.length(); ++i)
+			result[i] = x[i] * y[i];
+		return result;
+	}
+
+	template<typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
+	GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'outerProduct' only accept floating-point inputs");
+		return detail::compute_outerProduct<vecTypeA, vecTypeB, T, P>::call(c, r);
+	}
+
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_QUALIFIER typename matType<T, P>::transpose_type transpose(matType<T, P> const & m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'transpose' only accept floating-point inputs");
+		return detail::compute_transpose<matType, T, P>::call(m);
+	}
+
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_QUALIFIER T determinant(matType<T, P> const & m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'determinant' only accept floating-point inputs");
+		return detail::compute_determinant<matType, T, P>::call(m);
+	}
+
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_QUALIFIER matType<T, P> inverse(matType<T, P> const & m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inverse' only accept floating-point inputs");
+		return detail::compute_inverse<matType, T, P>::call(m);
+	}
+
+}//namespace glm

app/android/jni/third-party/include/glm/detail/func_noise.hpp

@@ -0,0 +1,89 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/func_noise.hpp
+/// @date 2008-08-01 / 2011-06-18
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+/// 
+/// @defgroup core_func_noise Noise functions
+/// @ingroup core
+/// 
+/// Noise functions are stochastic functions that can be used to increase visual 
+/// complexity. Values returned by the following noise functions give the 
+/// appearance of randomness, but are not truly random.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "type_vec1.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "setup.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_noise
+	/// @{
+
+	/// Returns a 1D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise1.xml">GLSL noise1 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL typename genType::value_type noise1(genType const & x);
+
+	/// Returns a 2D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise2.xml">GLSL noise2 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL detail::tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
+
+	/// Returns a 3D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise3.xml">GLSL noise3 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL detail::tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
+
+	/// Returns a 4D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise4.xml">GLSL noise4 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL detail::tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
+
+	/// @}
+}//namespace glm
+
+#include "func_noise.inl"

app/android/jni/third-party/include/glm/detail/func_noise.inl

@@ -0,0 +1,384 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/core/func_noise.inl
+/// @date 2008-08-01 / 2011-09-27
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "../detail/_noise.hpp"
+#include "./func_common.hpp"
+
+namespace glm{
+namespace detail
+{
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> grad4(T const & j, detail::tvec4<T, P> const & ip)
+	{
+		detail::tvec3<T, P> pXYZ = floor(fract(detail::tvec3<T, P>(j) * detail::tvec3<T, P>(ip)) * T(7)) * ip[2] - T(1);
+		T pW = static_cast<T>(1.5) - dot(abs(pXYZ), detail::tvec3<T, P>(1));
+		detail::tvec4<T, P> s = detail::tvec4<T, P>(lessThan(detail::tvec4<T, P>(pXYZ, pW), detail::tvec4<T, P>(0.0)));
+		pXYZ = pXYZ + (detail::tvec3<T, P>(s) * T(2) - T(1)) * s.w; 
+		return detail::tvec4<T, P>(pXYZ, pW);
+	}
+}//namespace detail
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T noise1(T const & x)
+	{
+		return noise1(detail::tvec2<T, defaultp>(x, T(0)));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T, defaultp> noise2(T const & x)
+	{
+		return detail::tvec2<T, defaultp>(
+			noise1(x + T(0.0)),
+			noise1(x + T(1.0)));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, defaultp> noise3(T const & x)
+	{
+		return detail::tvec3<T, defaultp>(
+			noise1(x - T(1.0)),
+			noise1(x + T(0.0)),
+			noise1(x + T(1.0)));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T, defaultp> noise4(T const & x)
+	{
+		return detail::tvec4<T, defaultp>(
+			noise1(x - T(1.0)),
+			noise1(x + T(0.0)),
+			noise1(x + T(1.0)),
+			noise1(x + T(2.0)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T noise1(detail::tvec2<T, P> const & v)
+	{
+		detail::tvec4<T, P> const C = detail::tvec4<T, P>(
+			T( 0.211324865405187),		// (3.0 -  sqrt(3.0)) / 6.0
+			T( 0.366025403784439),		//  0.5 * (sqrt(3.0)  - 1.0)
+			T(-0.577350269189626),		// -1.0 + 2.0 * C.x
+			T( 0.024390243902439));		//  1.0 / 41.0
+		
+		// First corner
+		detail::tvec2<T, P> i  = floor(v + dot(v, detail::tvec2<T, P>(C[1])));
+		detail::tvec2<T, P> x0 = v -   i + dot(i, detail::tvec2<T, P>(C[0]));
+		
+		// Other corners
+		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+		//i1.y = 1.0 - i1.x;
+		detail::tvec2<T, P> i1 = (x0.x > x0.y) ? detail::tvec2<T, P>(1, 0) : detail::tvec2<T, P>(0, 1);
+
+		// x0 = x0 - 0.0 + 0.0 * C.xx ;
+		// x1 = x0 - i1 + 1.0 * C.xx ;
+		// x2 = x0 - 1.0 + 2.0 * C.xx ;
+		detail::tvec4<T, P> x12 = detail::tvec4<T, P>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T, P>(C.x, C.x, C.z, C.z);
+		x12 = detail::tvec4<T, P>(detail::tvec2<T, P>(x12) - i1, x12.z, x12.w);
+		
+		// Permutations
+		i = mod(i, T(289)); // Avoid truncation effects in permutation
+		detail::tvec3<T, P> p = detail::permute(
+			detail::permute(i.y + detail::tvec3<T, P>(T(0), i1.y, T(1))) + i.x + detail::tvec3<T, P>(T(0), i1.x, T(1)));
+		
+		detail::tvec3<T, P> m = max(T(0.5) - detail::tvec3<T, P>(
+			dot(x0, x0),
+			dot(detail::tvec2<T, P>(x12.x, x12.y), detail::tvec2<T, P>(x12.x, x12.y)),
+			dot(detail::tvec2<T, P>(x12.z, x12.w), detail::tvec2<T, P>(x12.z, x12.w))), T(0));
+		
+		m = m * m;
+		m = m * m;
+		
+		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
+		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+		
+		detail::tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
+		detail::tvec3<T, P> h = abs(x) - T(0.5);
+		detail::tvec3<T, P> ox = floor(x + T(0.5));
+		detail::tvec3<T, P> a0 = x - ox;
+		
+		// Normalise gradients implicitly by scaling m
+		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
+		m *= static_cast<T>(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
+		
+		// Compute final noise value at P
+		detail::tvec3<T, P> g;
+		g.x  = a0.x  * x0.x  + h.x  * x0.y;
+		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+		g.y = a0.y * x12.x + h.y * x12.y;
+		g.z = a0.z * x12.z + h.z * x12.w;
+		return T(130) * dot(m, g);
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T noise1(detail::tvec3<T, P> const & v)
+	{
+		detail::tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
+		detail::tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
+		
+		// First corner
+		detail::tvec3<T, P> i(floor(v + dot(v, detail::tvec3<T, P>(C.y))));
+		detail::tvec3<T, P> x0(v - i + dot(i, detail::tvec3<T, P>(C.x)));
+		
+		// Other corners
+		detail::tvec3<T, P> g(step(detail::tvec3<T, P>(x0.y, x0.z, x0.x), x0));
+		detail::tvec3<T, P> l(T(1) - g);
+		detail::tvec3<T, P> i1(min(g, detail::tvec3<T, P>(l.z, l.x, l.y)));
+		detail::tvec3<T, P> i2(max(g, detail::tvec3<T, P>(l.z, l.x, l.y)));
+		
+		// x0 = x0 - 0.0 + 0.0 * C.xxx;
+		// x1 = x0 - i1  + 1.0 * C.xxx;
+		// x2 = x0 - i2  + 2.0 * C.xxx;
+		// x3 = x0 - 1.0 + 3.0 * C.xxx;
+		detail::tvec3<T, P> x1(x0 - i1 + C.x);
+		detail::tvec3<T, P> x2(x0 - i2 + C.y);		// 2.0*C.x = 1/3 = C.y
+		detail::tvec3<T, P> x3(x0 - D.y);			// -1.0+3.0*C.x = -0.5 = -D.y
+		
+		// Permutations
+		i = mod289(i); 
+		detail::tvec4<T, P> p(detail::permute(detail::permute(detail::permute(
+			i.z + detail::tvec4<T, P>(T(0), i1.z, i2.z, T(1))) +
+			i.y + detail::tvec4<T, P>(T(0), i1.y, i2.y, T(1))) +
+			i.x + detail::tvec4<T, P>(T(0), i1.x, i2.x, T(1))));
+		
+		// Gradients: 7x7 points over a square, mapped onto an octahedron.
+		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+		T n_ = static_cast<T>(0.142857142857); // 1.0/7.0
+		detail::tvec3<T, P> ns(n_ * detail::tvec3<T, P>(D.w, D.y, D.z) - detail::tvec3<T, P>(D.x, D.z, D.x));
+		
+		detail::tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z));	// mod(p,7*7)
+		
+		detail::tvec4<T, P> x_(floor(j * ns.z));
+		detail::tvec4<T, P> y_(floor(j - T(7) * x_));				// mod(j,N)
+		
+		detail::tvec4<T, P> x(x_ * ns.x + ns.y);
+		detail::tvec4<T, P> y(y_ * ns.x + ns.y);
+		detail::tvec4<T, P> h(T(1) - abs(x) - abs(y));
+		
+		detail::tvec4<T, P> b0(x.x, x.y, y.x, y.y);
+		detail::tvec4<T, P> b1(x.z, x.w, y.z, y.w);
+		
+		// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
+		// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
+		detail::tvec4<T, P> s0(floor(b0) * T(2) + T(1));
+		detail::tvec4<T, P> s1(floor(b1) * T(2) + T(1));
+		detail::tvec4<T, P> sh(-step(h, detail::tvec4<T, P>(0.0)));
+		
+		detail::tvec4<T, P> a0 = detail::tvec4<T, P>(b0.x, b0.z, b0.y, b0.w) + detail::tvec4<T, P>(s0.x, s0.z, s0.y, s0.w) * detail::tvec4<T, P>(sh.x, sh.x, sh.y, sh.y);
+		detail::tvec4<T, P> a1 = detail::tvec4<T, P>(b1.x, b1.z, b1.y, b1.w) + detail::tvec4<T, P>(s1.x, s1.z, s1.y, s1.w) * detail::tvec4<T, P>(sh.z, sh.z, sh.w, sh.w);
+		
+		detail::tvec3<T, P> p0(a0.x, a0.y, h.x);
+		detail::tvec3<T, P> p1(a0.z, a0.w, h.y);
+		detail::tvec3<T, P> p2(a1.x, a1.y, h.z);
+		detail::tvec3<T, P> p3(a1.z, a1.w, h.w);
+		
+		// Normalise gradients
+		detail::tvec4<T, P> norm = taylorInvSqrt(detail::tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		p0 *= norm.x;
+		p1 *= norm.y;
+		p2 *= norm.z;
+		p3 *= norm.w;
+		
+		// Mix final noise value
+		detail::tvec4<T, P> m = max(T(0.6) - detail::tvec4<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
+		m = m * m;
+		return T(42) * dot(m * m, detail::tvec4<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T noise1(detail::tvec4<T, P> const & v)
+	{
+		detail::tvec4<T, P> const C(
+			0.138196601125011,		// (5 - sqrt(5))/20  G4
+			0.276393202250021,		// 2 * G4
+			0.414589803375032,		// 3 * G4
+			-0.447213595499958);	// -1 + 4 * G4
+		
+		// (sqrt(5) - 1)/4 = F4, used once below
+		T const F4 = static_cast<T>(0.309016994374947451);
+		
+		// First corner
+		detail::tvec4<T, P> i  = floor(v + dot(v, detail::tvec4<T, P>(F4)));
+		detail::tvec4<T, P> x0 = v -   i + dot(i, detail::tvec4<T, P>(C.x));
+		
+		// Other corners
+		
+		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
+		detail::tvec4<T, P> i0;
+		detail::tvec3<T, P> isX = step(detail::tvec3<T, P>(x0.y, x0.z, x0.w), detail::tvec3<T, P>(x0.x));
+		detail::tvec3<T, P> isYZ = step(detail::tvec3<T, P>(x0.z, x0.w, x0.w), detail::tvec3<T, P>(x0.y, x0.y, x0.z));
+		
+		//  i0.x = dot(isX, vec3(1.0));
+		//i0.x = isX.x + isX.y + isX.z;
+		//i0.yzw = static_cast<T>(1) - isX;
+		i0 = detail::tvec4<T, P>(isX.x + isX.y + isX.z, T(1) - isX);
+		
+		//  i0.y += dot(isYZ.xy, vec2(1.0));
+		i0.y += isYZ.x + isYZ.y;
+		
+		//i0.zw += 1.0 - detail::tvec2<T, P>(isYZ.x, isYZ.y);
+		i0.z += static_cast<T>(1) - isYZ.x;
+		i0.w += static_cast<T>(1) - isYZ.y;
+		i0.z += isYZ.z;
+		i0.w += static_cast<T>(1) - isYZ.z;
+		
+		// i0 now contains the unique values 0,1,2,3 in each channel
+		detail::tvec4<T, P> i3 = clamp(i0, T(0), T(1));
+		detail::tvec4<T, P> i2 = clamp(i0 - T(1), T(0), T(1));
+		detail::tvec4<T, P> i1 = clamp(i0 - T(2), T(0), T(1));
+		
+		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
+		//  x1 = x0 - i1  + 0.0 * C.xxxx
+		//  x2 = x0 - i2  + 0.0 * C.xxxx
+		//  x3 = x0 - i3  + 0.0 * C.xxxx
+		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
+		detail::tvec4<T, P> x1 = x0 - i1 + C.x;
+		detail::tvec4<T, P> x2 = x0 - i2 + C.y;
+		detail::tvec4<T, P> x3 = x0 - i3 + C.z;
+		detail::tvec4<T, P> x4 = x0 + C.w;
+		
+		// Permutations
+		i = mod(i, T(289));
+		T j0 = detail::permute(detail::permute(detail::permute(detail::permute(i.w) + i.z) + i.y) + i.x);
+		detail::tvec4<T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
+			i.w + detail::tvec4<T, P>(i1.w, i2.w, i3.w, T(1))) +
+			i.z + detail::tvec4<T, P>(i1.z, i2.z, i3.z, T(1))) +
+			i.y + detail::tvec4<T, P>(i1.y, i2.y, i3.y, T(1))) +
+			i.x + detail::tvec4<T, P>(i1.x, i2.x, i3.x, T(1)));
+		
+		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
+		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
+		detail::tvec4<T, P> ip = detail::tvec4<T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
+		
+		detail::tvec4<T, P> p0 = detail::grad4(j0,   ip);
+		detail::tvec4<T, P> p1 = detail::grad4(j1.x, ip);
+		detail::tvec4<T, P> p2 = detail::grad4(j1.y, ip);
+		detail::tvec4<T, P> p3 = detail::grad4(j1.z, ip);
+		detail::tvec4<T, P> p4 = detail::grad4(j1.w, ip);
+		
+		// Normalise gradients
+		detail::tvec4<T, P> norm = detail::taylorInvSqrt(detail::tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		p0 *= norm.x;
+		p1 *= norm.y;
+		p2 *= norm.z;
+		p3 *= norm.w;
+		p4 *= taylorInvSqrt(dot(p4, p4));
+		
+		// Mix contributions from the five corners
+		detail::tvec3<T, P> m0 = max(T(0.6) - detail::tvec3<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
+		detail::tvec2<T, P> m1 = max(T(0.6) - detail::tvec2<T, P>(dot(x3, x3), dot(x4, x4)             ), T(0));
+		m0 = m0 * m0;
+		m1 = m1 * m1;
+		
+		return T(49) * (
+			dot(m0 * m0, detail::tvec3<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
+			dot(m1 * m1, detail::tvec2<T, P>(dot(p3, x3), dot(p4, x4))));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec2<T, P> const & x)
+	{
+		return detail::tvec2<T, P>(
+			noise1(x + detail::tvec2<T, P>(0.0)),
+			noise1(detail::tvec2<T, P>(0.0) - x));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec3<T, P> const & x)
+	{
+		return detail::tvec2<T, P>(
+			noise1(x + detail::tvec3<T, P>(0.0)),
+			noise1(detail::tvec3<T, P>(0.0) - x));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec4<T, P> const & x)
+	{
+		return detail::tvec2<T, P>(
+			noise1(x + detail::tvec4<T, P>(0)),
+			noise1(detail::tvec4<T, P>(0) - x));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec2<T, P> const & x)
+	{
+		return detail::tvec3<T, P>(
+			noise1(x - detail::tvec2<T, P>(1.0)),
+			noise1(x + detail::tvec2<T, P>(0.0)),
+			noise1(x + detail::tvec2<T, P>(1.0)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec3<T, P> const & x)
+	{
+		return detail::tvec3<T, P>(
+			noise1(x - detail::tvec3<T, P>(1.0)),
+			noise1(x + detail::tvec3<T, P>(0.0)),
+			noise1(x + detail::tvec3<T, P>(1.0)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec4<T, P> const & x)
+	{
+		return detail::tvec3<T, P>(
+			noise1(x - detail::tvec4<T, P>(1)),
+			noise1(x + detail::tvec4<T, P>(0)),
+			noise1(x + detail::tvec4<T, P>(1)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec2<T, P> const & x)
+	{
+		return detail::tvec4<T, P>(
+			noise1(x - detail::tvec2<T, P>(1)),
+			noise1(x + detail::tvec2<T, P>(0)),
+			noise1(x + detail::tvec2<T, P>(1)),
+			noise1(x + detail::tvec2<T, P>(2)));
+	}
+
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec3<T, P> const & x)
+	{
+		return detail::tvec4<T, P>(
+			noise1(x - detail::tvec3<T, P>(1)),
+			noise1(x + detail::tvec3<T, P>(0)),
+			noise1(x + detail::tvec3<T, P>(1)),
+			noise1(x + detail::tvec3<T, P>(2)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec4<T, P> const & x)
+	{
+		return detail::tvec4<T, P>(
+			noise1(x - detail::tvec4<T, P>(1)),
+			noise1(x + detail::tvec4<T, P>(0)),
+			noise1(x + detail::tvec4<T, P>(1)),
+			noise1(x + detail::tvec4<T, P>(2)));
+	}
+	
+}//namespace glm