fix gles3jni bug b/37001153

main page README.md update

.gitignore

@@ -0,0 +1,7 @@
+.gradle
+.idea
+**/*.iml
+local.properties
+build
+*~
+.DS_Store

.travis.yml

@@ -0,0 +1,40 @@
+language: android
+sudo: true
+android:
+  components:
+    - tools
+    - platform-tools
+    - build-tools-23.0.2
+    - android-23
+    - extra-google-m2repository
+    - extra-android-m2repository
+addons:
+  apt_packages:
+    - pandoc
+  artifacts:
+    paths:
+      - $(git ls-files -o | grep app/build/outputs | tr "\n" ":")
+before_install:
+  - git clone https://github.com/urho3d/android-ndk.git $HOME/android-ndk-root
+  - export ANDROID_NDK_HOME=$HOME/android-ndk-root
+script:
+  # check that all Support section of the README are the same.
+  - for f in */README.md; do sed -n '/Support/,/License/p' $f > /tmp/$(dirname $f).readme; done && diff -u --from-file=/tmp/hello-jni.readme /tmp/*.readme
+  # check that all compileSdkVersion are 23.
+  - test "$(grep -H compileSdkVersion */app/build.gradle | tee /dev/stderr | cut -d= -f 2 | sort | uniq | wc -l)" = "1"
+  # check that all targetSdkVersion are 22 or 23
+  - test "$(grep -H targetSdkVersion */app/build.gradle | tee /dev/stderr | cut -d= -f 2 | sort | uniq | wc -l)" = "2"
+  # check that all build-tools-23 are 23.
+  - test "$(grep -H buildToolsVersion */app/build.gradle | tee /dev/stderr | cut -d= -f 2 | sort | uniq | wc -l)" = "1"
+  # check that there is no tabs in AndroidManifest
+  - |-
+    (! grep -n $'\t' */app/src/main/AndroidManifest.xml) | cat -t; test ${PIPESTATUS[0]} -eq 0
+  # check that there is no trailing spaces in AndroidManifest    
+  - |-
+    (! grep -E '\s+$' */app/src/main/AndroidManifest.xml) | cat -e; test ${PIPESTATUS[0]} -eq 0
+  - (cd hello-thirdparty && ./gradlew download_and_stage_gpg_sdk)
+  - (cd builder && ./gradlew test)
+  # print build failure summary
+  - pandoc builder/build/reports/tests/index.html -t plain | sed -n '/^Failed tests/,/default-package/p'
+  # print lint results details
+  # - for f in */app/build/outputs/lint-results.html; do pandoc $f -t plain; done

CONTRIBUTING.md

@@ -31,26 +31,3 @@ accept your pull requests.
 1. The repo owner will review your request. If it is approved, the change will
    be merged. If it needs additional work, the repo owner will respond with
    useful comments.
-
-## Contributing a New Sample App
-
-1. Sign a Contributor License Agreement, if you have not yet done so (see
-   details above).
-1. Create your own repo for your app following this naming convention:
-    * mirror-{app-name}-{language or plaform}
-    * apps: quickstart, photohunt-server, photohunt-client
-    * example:  mirror-quickstart-android
-    * For multi-language apps, concatenate the primary languages like this:
-      mirror-photohunt-server-java-python.
-
-1. Create your sample app in this repo.
-    * Be sure to clone the README.md, CONTRIBUTING.md and LICENSE files from the
-      googlecast repo.
-    * Ensure that your code is clear and comprehensible.
-    * Ensure that your code has an appropriate set of unit tests which all pass.
-    * Instructional value is the top priority when evaluating new app proposals for
-      this collection of repos.
-1. Submit a request to fork your repo in googlecast organization.
-1. The repo owner will review your request. If it is approved, the sample will
-   be merged. If it needs additional work, the repo owner will respond with 
-   useful comments.

MoreTeapots/.google/packaging.yaml

@@ -0,0 +1,7 @@
+status:       PUBLISHED
+technologies: [Android, NDK]
+categories:   [NDK, C++]
+languages:    [C++, Java]
+solutions:    [Mobile]
+github:       googlesamples/android-ndk
+license:      apache2

MoreTeapots/AndroidManifest.xml

@@ -1,34 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.sample.moreteapots"
-    android:versionCode="1"
-    android:versionName="1.0" >
-
-    <uses-sdk
-        android:minSdkVersion="11"
-        android:targetSdkVersion="19" />
-    <uses-feature android:glEsVersion="0x00020000"></uses-feature>
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
-    <application
-        android:allowBackup="true"
-        android:icon="@drawable/ic_launcher"
-        android:label="@string/app_name"
-        android:theme="@style/AppTheme"
-        android:hasCode="true"
-        android:name="com.sample.moreteapots.MoreTeapotsApplication"
-        >
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="com.sample.moreteapots.MoreTeapotsNativeActivity"
-                android:label="@string/app_name"
-                android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of or .so -->
-            <meta-data android:name="android.app.lib_name"
-                    android:value="MoreTeapotsNativeActivity" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>

MoreTeapots/README.md

@@ -0,0 +1,53 @@
+More Teapots
+============
+More Teapots is an Android C++ sample that draws multiple instances of the same Teapot mesh using GLES 3.0 Instanced Rendering and [NativeActivity](http://developer.android.com/reference/android/app/NativeActivity.html).
+
+This sample uses the new [Gradle Experimental Android plugin](http://tools.android.com/tech-docs/new-build-system/gradle-experimental) with C++ support.
+
+Pre-requisites
+--------------
+- Android Studio 1.3+ with [NDK](https://developer.android.com/ndk/) bundle.
+
+Getting Started
+---------------
+1. [Download Android Studio](http://developer.android.com/sdk/index.html)
+1. Launch Android Studio.
+1. Open the sample directory.
+1. Open *File/Project Structure...*
+  - Click *Download* or *Select NDK location*.
+1. Click *Tools/Android/Sync Project with Gradle Files*.
+1. Click *Run/Run 'app'*.
+
+Screenshots
+-----------
+![screenshot](screenshot.png)
+
+Support
+-------
+If you've found an error in these samples, please [file an issue](https://github.com/googlesamples/android-ndk/issues/new).
+
+Patches are encouraged, and may be submitted by [forking this project](https://github.com/googlesamples/android-ndk/fork) and
+submitting a pull request through GitHub. Please see [CONTRIBUTING.md](../CONTRIBUTING.md) for more details.
+
+- [Stack Overflow](http://stackoverflow.com/questions/tagged/android-ndk)
+- [Google+ Community](https://plus.google.com/communities/105153134372062985968)
+- [Android Tools Feedbacks](http://tools.android.com/feedback)
+
+License
+-------
+Copyright 2015 Google, Inc.
+
+Licensed to the Apache Software Foundation (ASF) under one or more contributor
+license agreements.  See the NOTICE file distributed with this work for
+additional information regarding copyright ownership.  The ASF licenses this
+file to you 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.

MoreTeapots/app/build.gradle

@@ -0,0 +1,65 @@
+apply plugin: 'com.android.model.application'
+
+// Retrieve ndk path to config cpufeatures src code into this project
+// native_app_glue is configured as dependent module, so we avoid confusing
+// NOTICE/repo.prop files get displayed multiple times inside IDE
+def ndkDir = System.getenv("ANDROID_NDK_HOME")
+def propertiesFile = project.rootProject.file('local.properties')
+if (propertiesFile.exists()) {
+    Properties properties = new Properties()
+    properties.load(propertiesFile.newDataInputStream())
+    ndkDir = properties.getProperty('ndk.dir')
+}
+
+model {
+    android {
+        compileSdkVersion = 23
+        buildToolsVersion = '23.0.2'
+
+        defaultConfig {
+            applicationId    = 'com.sample.moreteapots'
+            minSdkVersion.apiLevel    = 17
+            targetSdkVersion.apiLevel = 22
+        }
+        ndk {
+            moduleName = 'MoreTeapotsNativeActivity'
+            // temporarily use gcc since clang does not work on windows (*)
+            // also clang warning about inline, so could not use -Wall, -Werror
+            // toolchain = "clang"
+            stl       = 'gnustl_static'
+            cppFlags.addAll(['-I' + "${ndkDir}/sources/android/cpufeatures",
+                             '-I' + file('src/main/jni/ndk_helper')])
+            cppFlags.addAll(['-std=c++11', '-Werror', '-Wall',
+                             '-fno-exceptions', '-fno-rtti'])
+            ldLibs.addAll(['android', 'log', 'EGL', 'GLESv2','atomic'])
+        }
+        // Turn on hard float support in armeabi-v7a
+        abis {
+            create('armeabi-v7a') {
+                cppFlags.addAll(['-mhard-float', '-D_NDK_MATH_NO_SOFTFP=1',
+                                 '-mfloat-abi=hard'])
+                ldLibs.add('m_hard')
+                ldFlags.add('-Wl,--no-warn-mismatch')
+            }
+        }
+        sources {
+            main {
+                jni {
+                    dependencies {
+                        project ':nativeactivity' linkage 'static'
+                    }
+                    source {
+                        srcDirs 'src/main/jni'
+                        srcDirs "${ndkDir}/sources/android/cpufeatures"
+                    }
+                }
+            }
+        }
+        buildTypes {
+            release {
+                minifyEnabled = false
+                proguardFiles.add(file('proguard-rules.txt'))
+            }
+        }
+    }
+}

MoreTeapots/app/src/main/AndroidManifest.xml

@@ -0,0 +1,32 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.sample.moreteapots"
+          android:versionCode="1"
+          android:versionName="1.0" >
+
+  <uses-feature android:glEsVersion="0x00020000"></uses-feature>
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
+  <application
+      android:allowBackup="false"
+      android:fullBackupContent="false"
+      android:supportsRtl="true"
+      android:icon="@mipmap/ic_launcher"
+      android:label="@string/app_name"
+      android:theme="@style/AppTheme"
+      android:name="com.sample.moreteapots.MoreTeapotsApplication"
+      >
+
+    <!-- Our activity is the built-in NativeActivity framework class.
+         This will take care of integrating with our NDK code. -->
+    <activity android:name="com.sample.moreteapots.MoreTeapotsNativeActivity"
+              android:label="@string/app_name"
+              android:configChanges="orientation|keyboardHidden">
+      <!-- Tell NativeActivity the name of or .so -->
+      <meta-data android:name="android.app.lib_name"
+                 android:value="MoreTeapotsNativeActivity" />
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+    </activity>
+  </application>
+</manifest>

MoreTeapots/app/src/main/java/com/sample/helper/NDKHelper.java

@@ -21,6 +21,8 @@ import java.io.FileInputStream;
 
 import javax.microedition.khronos.opengles.GL10;
 
+import android.annotation.TargetApi;
+
 import android.content.Context;
 import android.content.pm.ApplicationInfo;
 import android.graphics.Bitmap;
@@ -178,6 +180,7 @@ public class NDKHelper
         return "/system/lib/";
     }
 
+    @TargetApi(17)
     public int getNativeAudioBufferSize()
     {
         int SDK_INT = android.os.Build.VERSION.SDK_INT;
@@ -199,5 +202,4 @@ public class NDKHelper
         return AudioTrack.getNativeOutputSampleRate(AudioManager.STREAM_SYSTEM);
 
     }
-
 }

MoreTeapots/app/src/main/java/com/sample/moreteapots/MoreTeapotsApplication.java

@@ -35,6 +35,8 @@ import android.widget.Toast;
 public class MoreTeapotsApplication extends Application {
     private static Context context;
     public void onCreate(){
+        super.onCreate();
+
         context=getApplicationContext();
         NDKHelper.setContext(context);
         Log.w("native-activity", "onCreate");

MoreTeapots/app/src/main/java/com/sample/moreteapots/MoreTeapotsNativeActivity.java

@@ -16,6 +16,8 @@
 
 package com.sample.moreteapots;
 
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
 import android.app.NativeActivity;
 import android.content.res.Configuration;
 import android.os.Bundle;
@@ -51,6 +53,7 @@ public class MoreTeapotsNativeActivity extends NativeActivity {
 
     }
 
+    @TargetApi(19)
     protected void onResume() {
         super.onResume();
 
@@ -73,14 +76,10 @@ public class MoreTeapotsNativeActivity extends NativeActivity {
     protected void onPause()
     {
         super.onPause();
-        if (_popupWindow != null) {
-
-            _popupWindow.dismiss();
-            _popupWindow = null;
-        }
     }
     // Our popup window, you will call it from your C/C++ code later
 
+    @TargetApi(19)
     void setImmersiveSticky() {
         View decorView = getWindow().getDecorView();
         decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_FULLSCREEN
@@ -95,6 +94,7 @@ public class MoreTeapotsNativeActivity extends NativeActivity {
     PopupWindow _popupWindow;
     TextView _label;
 
+    @SuppressLint("InflateParams")
     public void showUI()
     {
         if( _popupWindow != null )
@@ -120,7 +120,7 @@ public class MoreTeapotsNativeActivity extends NativeActivity {
                 _activity.setContentView(mainLayout, params);
 
                 // Show our UI over NativeActivity window
-                _popupWindow.showAtLocation(mainLayout, Gravity.TOP | Gravity.LEFT, 10, 10);
+                _popupWindow.showAtLocation(mainLayout, Gravity.TOP | Gravity.START, 10, 10);
                 _popupWindow.update();
 
                 _label = (TextView)popupView.findViewById(R.id.textViewFPS);

MoreTeapots/app/src/main/jni/MoreTeapotsNativeActivity.cpp

@@ -0,0 +1,438 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 files
+//--------------------------------------------------------------------------------
+#include <jni.h>
+#include <errno.h>
+
+#include <vector>
+#include <EGL/egl.h>
+#include <GLES/gl.h>
+
+#include <android/sensor.h>
+#include <android/log.h>
+#include <android_native_app_glue.h>
+#include <android/native_window_jni.h>
+#include <cpu-features.h>
+
+#include "MoreTeapotsRenderer.h"
+
+//-------------------------------------------------------------------------
+// Preprocessor
+//-------------------------------------------------------------------------
+#define HELPER_CLASS_NAME \
+  "com/sample/helper/NDKHelper"  // Class name of helper function
+//-------------------------------------------------------------------------
+// Constants
+//-------------------------------------------------------------------------
+const int32_t NUM_TEAPOTS_X = 8;
+const int32_t NUM_TEAPOTS_Y = 8;
+const int32_t NUM_TEAPOTS_Z = 8;
+
+//-------------------------------------------------------------------------
+// Shared state for our app.
+//-------------------------------------------------------------------------
+struct android_app;
+class Engine {
+  MoreTeapotsRenderer renderer_;
+
+  ndk_helper::GLContext* gl_context_;
+
+  bool initialized_resources_;
+  bool has_focus_;
+
+  ndk_helper::DoubletapDetector doubletap_detector_;
+  ndk_helper::PinchDetector pinch_detector_;
+  ndk_helper::DragDetector drag_detector_;
+  ndk_helper::PerfMonitor monitor_;
+
+  ndk_helper::TapCamera tap_camera_;
+
+  android_app* app_;
+
+  ASensorManager* sensor_manager_;
+  const ASensor* accelerometer_sensor_;
+  ASensorEventQueue* sensor_event_queue_;
+
+  void UpdateFPS(float fps);
+  void ShowUI();
+  void TransformPosition(ndk_helper::Vec2& vec);
+
+ public:
+  static void HandleCmd(struct android_app* app, int32_t cmd);
+  static int32_t HandleInput(android_app* app, AInputEvent* event);
+
+  Engine();
+  ~Engine();
+  void SetState(android_app* state);
+  int InitDisplay();
+  void LoadResources();
+  void UnloadResources();
+  void DrawFrame();
+  void TermDisplay();
+  void TrimMemory();
+  bool IsReady();
+
+  void UpdatePosition(AInputEvent* event, int32_t index, float& x, float& y);
+
+  void InitSensors();
+  void ProcessSensors(int32_t id);
+  void SuspendSensors();
+  void ResumeSensors();
+};
+
+//-------------------------------------------------------------------------
+// Ctor
+//-------------------------------------------------------------------------
+Engine::Engine()
+    : initialized_resources_(false),
+      has_focus_(false),
+      app_(NULL),
+      sensor_manager_(NULL),
+      accelerometer_sensor_(NULL),
+      sensor_event_queue_(NULL) {
+  gl_context_ = ndk_helper::GLContext::GetInstance();
+}
+
+//-------------------------------------------------------------------------
+// Dtor
+//-------------------------------------------------------------------------
+Engine::~Engine() {}
+
+/**
+ * Load resources
+ */
+void Engine::LoadResources() {
+  renderer_.Init(NUM_TEAPOTS_X, NUM_TEAPOTS_Y, NUM_TEAPOTS_Z);
+  renderer_.Bind(&tap_camera_);
+}
+
+/**
+ * Unload resources
+ */
+void Engine::UnloadResources() { renderer_.Unload(); }
+
+/**
+ * Initialize an EGL context for the current display.
+ */
+int Engine::InitDisplay() {
+  if (!initialized_resources_) {
+    gl_context_->Init(app_->window);
+    LoadResources();
+    initialized_resources_ = true;
+  } else {
+    // initialize OpenGL ES and EGL
+    if (EGL_SUCCESS != gl_context_->Resume(app_->window)) {
+      UnloadResources();
+      LoadResources();
+    }
+  }
+
+  ShowUI();
+
+  // Initialize GL state.
+  glEnable(GL_CULL_FACE);
+  glEnable(GL_DEPTH_TEST);
+  glDepthFunc(GL_LEQUAL);
+
+  // Note that screen size might have been changed
+  glViewport(0, 0, gl_context_->GetScreenWidth(), gl_context_->GetScreenHeight());
+  renderer_.UpdateViewport();
+
+  tap_camera_.SetFlip(1.f, -1.f, -1.f);
+  tap_camera_.SetPinchTransformFactor(10.f, 10.f, 8.f);
+
+  return 0;
+}
+
+/**
+ * Just the current frame in the display.
+ */
+void Engine::DrawFrame() {
+  float fps;
+  if (monitor_.Update(fps)) {
+    UpdateFPS(fps);
+  }
+  double dTime = monitor_.GetCurrentTime();
+  renderer_.Update(dTime);
+
+  // Just fill the screen with a color.
+  glClearColor(0.5f, 0.5f, 0.5f, 1.f);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  renderer_.Render();
+
+  // Swap
+  if (EGL_SUCCESS != gl_context_->Swap()) {
+    UnloadResources();
+    LoadResources();
+  }
+}
+
+/**
+ * Tear down the EGL context currently associated with the display.
+ */
+void Engine::TermDisplay() { gl_context_->Suspend(); }
+
+void Engine::TrimMemory() {
+  LOGI("Trimming memory");
+  gl_context_->Invalidate();
+}
+/**
+ * Process the next input event.
+ */
+int32_t Engine::HandleInput(android_app* app, AInputEvent* event) {
+  Engine* eng = (Engine*)app->userData;
+  if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) {
+    ndk_helper::GESTURE_STATE doubleTapState =
+        eng->doubletap_detector_.Detect(event);
+    ndk_helper::GESTURE_STATE dragState = eng->drag_detector_.Detect(event);
+    ndk_helper::GESTURE_STATE pinchState = eng->pinch_detector_.Detect(event);
+
+    // Double tap detector has a priority over other detectors
+    if (doubleTapState == ndk_helper::GESTURE_STATE_ACTION) {
+      // Detect double tap
+      eng->tap_camera_.Reset(true);
+    } else {
+      // Handle drag state
+      if (dragState & ndk_helper::GESTURE_STATE_START) {
+        // Otherwise, start dragging
+        ndk_helper::Vec2 v;
+        eng->drag_detector_.GetPointer(v);
+        eng->TransformPosition(v);
+        eng->tap_camera_.BeginDrag(v);
+      } else if (dragState & ndk_helper::GESTURE_STATE_MOVE) {
+        ndk_helper::Vec2 v;
+        eng->drag_detector_.GetPointer(v);
+        eng->TransformPosition(v);
+        eng->tap_camera_.Drag(v);
+      } else if (dragState & ndk_helper::GESTURE_STATE_END) {
+        eng->tap_camera_.EndDrag();
+      }
+
+      // Handle pinch state
+      if (pinchState & ndk_helper::GESTURE_STATE_START) {
+        // Start new pinch
+        ndk_helper::Vec2 v1;
+        ndk_helper::Vec2 v2;
+        eng->pinch_detector_.GetPointers(v1, v2);
+        eng->TransformPosition(v1);
+        eng->TransformPosition(v2);
+        eng->tap_camera_.BeginPinch(v1, v2);
+      } else if (pinchState & ndk_helper::GESTURE_STATE_MOVE) {
+        // Multi touch
+        // Start new pinch
+        ndk_helper::Vec2 v1;
+        ndk_helper::Vec2 v2;
+        eng->pinch_detector_.GetPointers(v1, v2);
+        eng->TransformPosition(v1);
+        eng->TransformPosition(v2);
+        eng->tap_camera_.Pinch(v1, v2);
+      }
+    }
+    return 1;
+  }
+  return 0;
+}
+
+/**
+ * Process the next main command.
+ */
+void Engine::HandleCmd(struct android_app* app, int32_t cmd) {
+  Engine* eng = (Engine*)app->userData;
+  switch (cmd) {
+    case APP_CMD_SAVE_STATE:
+      break;
+    case APP_CMD_INIT_WINDOW:
+      // The window is being shown, get it ready.
+      if (app->window != NULL) {
+        eng->InitDisplay();
+        eng->DrawFrame();
+      }
+      break;
+    case APP_CMD_TERM_WINDOW:
+      // The window is being hidden or closed, clean it up.
+      eng->TermDisplay();
+      eng->has_focus_ = false;
+      break;
+    case APP_CMD_STOP:
+      break;
+    case APP_CMD_GAINED_FOCUS:
+      eng->ResumeSensors();
+      // Start animation
+      eng->has_focus_ = true;
+      break;
+    case APP_CMD_LOST_FOCUS:
+      eng->SuspendSensors();
+      // Also stop animating.
+      eng->has_focus_ = false;
+      eng->DrawFrame();
+      break;
+    case APP_CMD_LOW_MEMORY:
+      // Free up GL resources
+      eng->TrimMemory();
+      break;
+  }
+}
+
+//-------------------------------------------------------------------------
+// Sensor handlers
+//-------------------------------------------------------------------------
+void Engine::InitSensors() {
+  sensor_manager_ = ASensorManager_getInstance();
+  accelerometer_sensor_ = ASensorManager_getDefaultSensor(
+      sensor_manager_, ASENSOR_TYPE_ACCELEROMETER);
+  sensor_event_queue_ = ASensorManager_createEventQueue(
+      sensor_manager_, app_->looper, LOOPER_ID_USER, NULL, NULL);
+}
+
+void Engine::ProcessSensors(int32_t id) {
+  // If a sensor has data, process it now.
+  if (id == LOOPER_ID_USER) {
+    if (accelerometer_sensor_ != NULL) {
+      ASensorEvent event;
+      while (ASensorEventQueue_getEvents(sensor_event_queue_, &event, 1) > 0) {
+      }
+    }
+  }
+}
+
+void Engine::ResumeSensors() {
+  // When our app gains focus, we start monitoring the accelerometer.
+  if (accelerometer_sensor_ != NULL) {
+    ASensorEventQueue_enableSensor(sensor_event_queue_, accelerometer_sensor_);
+    // We'd like to get 60 events per second (in us).
+    ASensorEventQueue_setEventRate(sensor_event_queue_, accelerometer_sensor_,
+                                   (1000L / 60) * 1000);
+  }
+}
+
+void Engine::SuspendSensors() {
+  // When our app loses focus, we stop monitoring the accelerometer.
+  // This is to avoid consuming battery while not being used.
+  if (accelerometer_sensor_ != NULL) {
+    ASensorEventQueue_disableSensor(sensor_event_queue_, accelerometer_sensor_);
+  }
+}
+
+//-------------------------------------------------------------------------
+// Misc
+//-------------------------------------------------------------------------
+void Engine::SetState(android_app* state) {
+  app_ = state;
+  doubletap_detector_.SetConfiguration(app_->config);
+  drag_detector_.SetConfiguration(app_->config);
+  pinch_detector_.SetConfiguration(app_->config);
+}
+
+bool Engine::IsReady() {
+  if (has_focus_) return true;
+
+  return false;
+}
+
+void Engine::TransformPosition(ndk_helper::Vec2& vec) {
+  vec = ndk_helper::Vec2(2.0f, 2.0f) * vec /
+            ndk_helper::Vec2(gl_context_->GetScreenWidth(),
+                             gl_context_->GetScreenHeight()) -
+        ndk_helper::Vec2(1.f, 1.f);
+}
+
+void Engine::ShowUI() {
+  JNIEnv* jni;
+  app_->activity->vm->AttachCurrentThread(&jni, NULL);
+
+  // Default class retrieval
+  jclass clazz = jni->GetObjectClass(app_->activity->clazz);
+  jmethodID methodID = jni->GetMethodID(clazz, "showUI", "()V");
+  jni->CallVoidMethod(app_->activity->clazz, methodID);
+
+  app_->activity->vm->DetachCurrentThread();
+  return;
+}
+
+void Engine::UpdateFPS(float fps) {
+  JNIEnv* jni;
+  app_->activity->vm->AttachCurrentThread(&jni, NULL);
+
+  // Default class retrieval
+  jclass clazz = jni->GetObjectClass(app_->activity->clazz);
+  jmethodID methodID = jni->GetMethodID(clazz, "updateFPS", "(F)V");
+  jni->CallVoidMethod(app_->activity->clazz, methodID, fps);
+
+  app_->activity->vm->DetachCurrentThread();
+  return;
+}
+
+Engine g_engine;
+
+/**
+ * This is the main entry point of a native application that is using
+ * android_native_app_glue.  It runs in its own thread, with its own
+ * event loop for receiving input events and doing other things.
+ */
+void android_main(android_app* state) {
+  app_dummy();
+
+  g_engine.SetState(state);
+
+  // Init helper functions
+  ndk_helper::JNIHelper::GetInstance()->Init(state->activity,
+                                             HELPER_CLASS_NAME);
+
+  state->userData = &g_engine;
+  state->onAppCmd = Engine::HandleCmd;
+  state->onInputEvent = Engine::HandleInput;
+
+#ifdef USE_NDK_PROFILER
+  monstartup("libMoreTeapotsNativeActivity.so");
+#endif
+
+  // Prepare to monitor accelerometer
+  g_engine.InitSensors();
+
+  // loop waiting for stuff to do.
+  while (1) {
+    // Read all pending events.
+    int id;
+    int events;
+    android_poll_source* source;
+
+    // If not animating, we will block forever waiting for events.
+    // If animating, we loop until all events are read, then continue
+    // to draw the next frame of animation.
+    while ((id = ALooper_pollAll(g_engine.IsReady() ? 0 : -1, NULL, &events,
+                                 (void**)&source)) >= 0) {
+      // Process this event.
+      if (source != NULL) source->process(state, source);
+
+      g_engine.ProcessSensors(id);
+
+      // Check if we are exiting.
+      if (state->destroyRequested != 0) {
+        g_engine.TermDisplay();
+        return;
+      }
+    }
+
+    if (g_engine.IsReady()) {
+      // Drawing is throttled to the screen update rate, so there
+      // is no need to do timing here.
+      g_engine.DrawFrame();
+    }
+  }
+}

MoreTeapots/app/src/main/jni/MoreTeapotsRenderer.cpp

@@ -0,0 +1,527 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//--------------------------------------------------------------------------------
+// MoreTeapotsRenderer.cpp
+// Render teapots
+//--------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------
+// Include files
+//--------------------------------------------------------------------------------
+#include "MoreTeapotsRenderer.h"
+
+//--------------------------------------------------------------------------------
+// Teapot model data
+//--------------------------------------------------------------------------------
+#include "teapot.inl"
+
+//--------------------------------------------------------------------------------
+// Ctor
+//--------------------------------------------------------------------------------
+MoreTeapotsRenderer::MoreTeapotsRenderer()
+    : geometry_instancing_support_(false) {}
+
+//--------------------------------------------------------------------------------
+// Dtor
+//--------------------------------------------------------------------------------
+MoreTeapotsRenderer::~MoreTeapotsRenderer() { Unload(); }
+
+//--------------------------------------------------------------------------------
+// Init
+//--------------------------------------------------------------------------------
+void MoreTeapotsRenderer::Init(const int32_t numX, const int32_t numY,
+                               const int32_t numZ) {
+  if (ndk_helper::GLContext::GetInstance()->GetGLVersion() >= 3.0) {
+    geometry_instancing_support_ = true;
+  } else if (ndk_helper::GLContext::GetInstance()->CheckExtension(
+                 "GL_NV_draw_instanced") &&
+             ndk_helper::GLContext::GetInstance()->CheckExtension(
+                 "GL_NV_uniform_buffer_object")) {
+    LOGI("Supported via extension!");
+    //_bGeometryInstancingSupport = true;
+    //_bARBSupport = true; //Need to patch shaders
+    // Currently this has been disabled
+  }
+
+  // Settings
+  glFrontFace(GL_CCW);
+
+  // Create Index buffer
+  num_indices_ = sizeof(teapotIndices) / sizeof(teapotIndices[0]);
+  glGenBuffers(1, &ibo_);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(teapotIndices), teapotIndices,
+               GL_STATIC_DRAW);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+  // Create VBO
+  num_vertices_ = sizeof(teapotPositions) / sizeof(teapotPositions[0]) / 3;
+  int32_t stride = sizeof(TEAPOT_VERTEX);
+  int32_t index = 0;
+  TEAPOT_VERTEX* p = new TEAPOT_VERTEX[num_vertices_];
+  for (int32_t i = 0; i < num_vertices_; ++i) {
+    p[i].pos[0] = teapotPositions[index];
+    p[i].pos[1] = teapotPositions[index + 1];
+    p[i].pos[2] = teapotPositions[index + 2];
+
+    p[i].normal[0] = teapotNormals[index];
+    p[i].normal[1] = teapotNormals[index + 1];
+    p[i].normal[2] = teapotNormals[index + 2];
+    index += 3;
+  }
+  glGenBuffers(1, &vbo_);
+  glBindBuffer(GL_ARRAY_BUFFER, vbo_);
+  glBufferData(GL_ARRAY_BUFFER, stride * num_vertices_, p, GL_STATIC_DRAW);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  delete[] p;
+
+  // Init Projection matrices
+  teapot_x_ = numX;
+  teapot_y_ = numY;
+  teapot_z_ = numZ;
+  vec_mat_models_.reserve(teapot_x_ * teapot_y_ * teapot_z_);
+
+  UpdateViewport();
+
+  const float total_width = 500.f;
+  float gap_x = total_width / (teapot_x_ - 1);
+  float gap_y = total_width / (teapot_y_ - 1);
+  float gap_z = total_width / (teapot_z_ - 1);
+  float offset_x = -total_width / 2.f;
+  float offset_y = -total_width / 2.f;
+  float offset_z = -total_width / 2.f;
+
+  for (int32_t x = 0; x < teapot_x_; ++x)
+    for (int32_t y = 0; y < teapot_y_; ++y)
+      for (int32_t z = 0; z < teapot_z_; ++z) {
+        vec_mat_models_.push_back(ndk_helper::Mat4::Translation(
+            x * gap_x + offset_x, y * gap_y + offset_y,
+            z * gap_z + offset_z));
+        vec_colors_.push_back(ndk_helper::Vec3(
+            random() / float(RAND_MAX * 1.1), random() / float(RAND_MAX * 1.1),
+            random() / float(RAND_MAX * 1.1)));
+
+        float rotation_x = random() / float(RAND_MAX) - 0.5f;
+        float rotation_y = random() / float(RAND_MAX) - 0.5f;
+        vec_rotations_.push_back(ndk_helper::Vec2(rotation_x * 0.05f, rotation_y * 0.05f));
+        vec_current_rotations_.push_back(
+            ndk_helper::Vec2(rotation_x * M_PI, rotation_y * M_PI));
+      }
+
+  if (geometry_instancing_support_) {
+    //
+    // Create parameter dictionary for shader patch
+    std::map<std::string, std::string> param;
+    param[std::string("%NUM_TEAPOT%")] =
+        ToString(teapot_x_ * teapot_y_ * teapot_z_);
+    param[std::string("%LOCATION_VERTEX%")] = ToString(ATTRIB_VERTEX);
+    param[std::string("%LOCATION_NORMAL%")] = ToString(ATTRIB_NORMAL);
+    if (arb_support_)
+      param[std::string("%ARB%")] = std::string("ARB");
+    else
+      param[std::string("%ARB%")] = std::string("");
+
+    // Load shader
+    bool b = LoadShadersES3(&shader_param_, "Shaders/VS_ShaderPlainES3.vsh",
+                            "Shaders/ShaderPlainES3.fsh", param);
+    if (b) {
+      //
+      // Create uniform buffer
+      //
+      GLuint bindingPoint = 1;
+      GLuint blockIndex;
+      blockIndex = glGetUniformBlockIndex(shader_param_.program_, "ParamBlock");
+      glUniformBlockBinding(shader_param_.program_, blockIndex, bindingPoint);
+
+      // Retrieve array stride value
+      int32_t num_indices;
+      glGetActiveUniformBlockiv(shader_param_.program_, blockIndex,
+                                GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &num_indices);
+      GLint i[num_indices];
+      GLint stride[num_indices];
+      glGetActiveUniformBlockiv(shader_param_.program_, blockIndex,
+                                GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, i);
+      glGetActiveUniformsiv(shader_param_.program_, num_indices, (GLuint*)i,
+                            GL_UNIFORM_ARRAY_STRIDE, stride);
+
+      ubo_matrix_stride_ = stride[0] / sizeof(float);
+      ubo_vector_stride_ = stride[2] / sizeof(float);
+
+      glGenBuffers(1, &ubo_);
+      glBindBuffer(GL_UNIFORM_BUFFER, ubo_);
+      glBindBufferBase(GL_UNIFORM_BUFFER, bindingPoint, ubo_);
+
+      // Store color value which wouldn't be updated every frame
+      int32_t size = teapot_x_ * teapot_y_ * teapot_z_ *
+                      (ubo_matrix_stride_ + ubo_matrix_stride_ +
+                       ubo_vector_stride_);  // Mat4 + Mat4 + Vec3 + 1 stride
+      float* pBuffer = new float[size];
+      float* pColor =
+          pBuffer + teapot_x_ * teapot_y_ * teapot_z_ * ubo_matrix_stride_ * 2;
+      for (int32_t i = 0; i < teapot_x_ * teapot_y_ * teapot_z_; ++i) {
+        memcpy(pColor, &vec_colors_[i], 3 * sizeof(float));
+        pColor += ubo_vector_stride_;  // Assuming std140 layout which is 4
+                                       // DWORD stride for vectors
+      }
+
+      glBufferData(GL_UNIFORM_BUFFER, size * sizeof(float), pBuffer,
+                   GL_DYNAMIC_DRAW);
+      delete[] pBuffer;
+    } else {
+      LOGI("Shader compilation failed!! Falls back to ES2.0 pass");
+      // This happens some devices.
+      geometry_instancing_support_ = false;
+      // Load shader for GLES2.0
+      LoadShaders(&shader_param_, "Shaders/VS_ShaderPlain.vsh",
+                  "Shaders/ShaderPlain.fsh");
+    }
+  } else {
+    // Load shader for GLES2.0
+    LoadShaders(&shader_param_, "Shaders/VS_ShaderPlain.vsh",
+                "Shaders/ShaderPlain.fsh");
+  }
+}
+
+void MoreTeapotsRenderer::UpdateViewport() {
+  int32_t viewport[4];
+  glGetIntegerv(GL_VIEWPORT, viewport);
+
+  const float CAM_NEAR = 5.f;
+  const float CAM_FAR = 10000.f;
+  if (viewport[2] < viewport[3]) {
+    float aspect =
+            static_cast<float>(viewport[2]) / static_cast<float>(viewport[3]);
+    mat_projection_ =
+            ndk_helper::Mat4::Perspective(aspect, 1.0f, CAM_NEAR, CAM_FAR);
+  } else {
+    float aspect =
+            static_cast<float>(viewport[3]) / static_cast<float>(viewport[2]);
+    mat_projection_ =
+            ndk_helper::Mat4::Perspective(1.0f, aspect, CAM_NEAR, CAM_FAR);
+  }
+}
+
+//--------------------------------------------------------------------------------
+// Unload
+//--------------------------------------------------------------------------------
+void MoreTeapotsRenderer::Unload() {
+  if (vbo_) {
+    glDeleteBuffers(1, &vbo_);
+    vbo_ = 0;
+  }
+  if (ubo_) {
+    glDeleteBuffers(1, &ubo_);
+    ubo_ = 0;
+  }
+  if (ibo_) {
+    glDeleteBuffers(1, &ibo_);
+    ibo_ = 0;
+  }
+  if (shader_param_.program_) {
+    glDeleteProgram(shader_param_.program_);
+    shader_param_.program_ = 0;
+  }
+}
+
+//--------------------------------------------------------------------------------
+// Update
+//--------------------------------------------------------------------------------
+void MoreTeapotsRenderer::Update(float fTime) {
+  const float CAM_X = 0.f;
+  const float CAM_Y = 0.f;
+  const float CAM_Z = 2000.f;
+
+  mat_view_ = ndk_helper::Mat4::LookAt(ndk_helper::Vec3(CAM_X, CAM_Y, CAM_Z),
+                                       ndk_helper::Vec3(0.f, 0.f, 0.f),
+                                       ndk_helper::Vec3(0.f, 1.f, 0.f));
+
+  if (camera_) {
+    camera_->Update();
+    mat_view_ = camera_->GetTransformMatrix() * mat_view_ *
+                camera_->GetRotationMatrix();
+  }
+}
+
+//--------------------------------------------------------------------------------
+// Render
+//--------------------------------------------------------------------------------
+void MoreTeapotsRenderer::Render() {
+  // Bind the VBO
+  glBindBuffer(GL_ARRAY_BUFFER, vbo_);
+
+  int32_t iStride = sizeof(TEAPOT_VERTEX);
+  // Pass the vertex data
+  glVertexAttribPointer(ATTRIB_VERTEX, 3, GL_FLOAT, GL_FALSE, iStride,
+                        BUFFER_OFFSET(0));
+  glEnableVertexAttribArray(ATTRIB_VERTEX);
+
+  glVertexAttribPointer(ATTRIB_NORMAL, 3, GL_FLOAT, GL_FALSE, iStride,
+                        BUFFER_OFFSET(3 * sizeof(GLfloat)));
+  glEnableVertexAttribArray(ATTRIB_NORMAL);
+
+  // Bind the IB
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_);
+
+  glUseProgram(shader_param_.program_);
+
+  TEAPOT_MATERIALS material = {{1.0f, 1.0f, 1.0f, 10.f}, {0.1f, 0.1f, 0.1f}, };
+
+  // Update uniforms
+  //
+  // using glUniform3fv here was troublesome..
+  //
+  glUniform4f(shader_param_.material_specular_, material.specular_color[0],
+              material.specular_color[1], material.specular_color[2],
+              material.specular_color[3]);
+  glUniform3f(shader_param_.material_ambient_, material.ambient_color[0],
+              material.ambient_color[1], material.ambient_color[2]);
+
+  glUniform3f(shader_param_.light0_, 100.f, -200.f, -600.f);
+
+  if (geometry_instancing_support_) {
+    //
+    // Geometry instancing, new feature in GLES3.0
+    //
+
+    // Update UBO
+    glBindBuffer(GL_UNIFORM_BUFFER, ubo_);
+    float* p = (float*)glMapBufferRange(
+        GL_UNIFORM_BUFFER, 0, teapot_x_ * teapot_y_ * teapot_z_ *
+                                  (ubo_matrix_stride_ * 2) * sizeof(float),
+        GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT);
+    float* mat_mvp = p;
+    float* mat_mv = p + teapot_x_ * teapot_y_ * teapot_z_ * ubo_matrix_stride_;
+    for (int32_t i = 0; i < teapot_x_ * teapot_y_ * teapot_z_; ++i) {
+      // Rotation
+      float x, y;
+      vec_current_rotations_[i] += vec_rotations_[i];
+      vec_current_rotations_[i].Value(x, y);
+      ndk_helper::Mat4 mat_rotation =
+          ndk_helper::Mat4::RotationX(x) * ndk_helper::Mat4::RotationY(y);
+
+      // Feed Projection and Model View matrices to the shaders
+      ndk_helper::Mat4 mat_v = mat_view_ * vec_mat_models_[i] * mat_rotation;
+      ndk_helper::Mat4 mat_vp = mat_projection_ * mat_v;
+
+      memcpy(mat_mvp, mat_vp.Ptr(), sizeof(mat_v));
+      mat_mvp += ubo_matrix_stride_;
+
+      memcpy(mat_mv, mat_v.Ptr(), sizeof(mat_v));
+      mat_mv += ubo_matrix_stride_;
+    }
+    glUnmapBuffer(GL_UNIFORM_BUFFER);
+
+    // Instanced rendering
+    glDrawElementsInstanced(GL_TRIANGLES, num_indices_, GL_UNSIGNED_SHORT,
+                            BUFFER_OFFSET(0),
+                            teapot_x_ * teapot_y_ * teapot_z_);
+
+  } else {
+    // Regular rendering pass
+    for (int32_t i = 0; i < teapot_x_ * teapot_y_ * teapot_z_; ++i) {
+      // Set diffuse
+      float x, y, z;
+      vec_colors_[i].Value(x, y, z);
+      glUniform4f(shader_param_.material_diffuse_, x, y, z, 1.f);
+
+      // Rotation
+      vec_current_rotations_[i] += vec_rotations_[i];
+      vec_current_rotations_[i].Value(x, y);
+      ndk_helper::Mat4 mat_rotation =
+          ndk_helper::Mat4::RotationX(x) * ndk_helper::Mat4::RotationY(y);
+
+      // Feed Projection and Model View matrices to the shaders
+      ndk_helper::Mat4 mat_v = mat_view_ * vec_mat_models_[i] * mat_rotation;
+      ndk_helper::Mat4 mat_vp = mat_projection_ * mat_v;
+      glUniformMatrix4fv(shader_param_.matrix_projection_, 1, GL_FALSE,
+                         mat_vp.Ptr());
+      glUniformMatrix4fv(shader_param_.matrix_view_, 1, GL_FALSE, mat_v.Ptr());
+
+      glDrawElements(GL_TRIANGLES, num_indices_, GL_UNSIGNED_SHORT,
+                     BUFFER_OFFSET(0));
+    }
+  }
+
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+}
+
+//--------------------------------------------------------------------------------
+// LoadShaders
+//--------------------------------------------------------------------------------
+bool MoreTeapotsRenderer::LoadShaders(SHADER_PARAMS* params, const char* strVsh,
+                                      const char* strFsh) {
+  //
+  // Shader load for GLES2
+  // In GLES2.0, shader attribute locations need to be explicitly specified
+  // before linking
+  //
+  GLuint program;
+  GLuint vertShader, fragShader;
+
+  // Create shader program
+  program = glCreateProgram();
+  LOGI("Created Shader %d", program);
+
+  // Create and compile vertex shader
+  if (!ndk_helper::shader::CompileShader(&vertShader, GL_VERTEX_SHADER,
+                                         strVsh)) {
+    LOGI("Failed to compile vertex shader");
+    glDeleteProgram(program);
+    return false;
+  }
+
+  // Create and compile fragment shader
+  if (!ndk_helper::shader::CompileShader(&fragShader, GL_FRAGMENT_SHADER,
+                                         strFsh)) {
+    LOGI("Failed to compile fragment shader");
+    glDeleteProgram(program);
+    return false;
+  }
+
+  // Attach vertex shader to program
+  glAttachShader(program, vertShader);
+
+  // Attach fragment shader to program
+  glAttachShader(program, fragShader);
+
+  // Bind attribute locations
+  // this needs to be done prior to linking
+  glBindAttribLocation(program, ATTRIB_VERTEX, "myVertex");
+  glBindAttribLocation(program, ATTRIB_NORMAL, "myNormal");
+
+  // Link program
+  if (!ndk_helper::shader::LinkProgram(program)) {
+    LOGI("Failed to link program: %d", program);
+
+    if (vertShader) {
+      glDeleteShader(vertShader);
+      vertShader = 0;
+    }
+    if (fragShader) {
+      glDeleteShader(fragShader);
+      fragShader = 0;
+    }
+    if (program) {
+      glDeleteProgram(program);
+    }
+    return false;
+  }
+
+  // Get uniform locations
+  params->matrix_projection_ = glGetUniformLocation(program, "uPMatrix");
+  params->matrix_view_ = glGetUniformLocation(program, "uMVMatrix");
+
+  params->light0_ = glGetUniformLocation(program, "vLight0");
+  params->material_diffuse_ = glGetUniformLocation(program, "vMaterialDiffuse");
+  params->material_ambient_ = glGetUniformLocation(program, "vMaterialAmbient");
+  params->material_specular_ =
+      glGetUniformLocation(program, "vMaterialSpecular");
+
+  // Release vertex and fragment shaders
+  if (vertShader) glDeleteShader(vertShader);
+  if (fragShader) glDeleteShader(fragShader);
+
+  params->program_ = program;
+  return true;
+}
+
+bool MoreTeapotsRenderer::LoadShadersES3(
+    SHADER_PARAMS* params, const char* strVsh, const char* strFsh,
+    std::map<std::string, std::string>& shaderParams) {
+  //
+  // Shader load for GLES3
+  // In GLES3.0, shader attribute index can be described in a shader code
+  // directly with layout() attribute
+  //
+  GLuint program;
+  GLuint vertShader, fragShader;
+
+  // Create shader program
+  program = glCreateProgram();
+  LOGI("Created Shader %d", program);
+
+  // Create and compile vertex shader
+  if (!ndk_helper::shader::CompileShader(&vertShader, GL_VERTEX_SHADER, strVsh,
+                                         shaderParams)) {
+    LOGI("Failed to compile vertex shader");
+    glDeleteProgram(program);
+    return false;
+  }
+
+  // Create and compile fragment shader
+  if (!ndk_helper::shader::CompileShader(&fragShader, GL_FRAGMENT_SHADER,
+                                         strFsh, shaderParams)) {
+    LOGI("Failed to compile fragment shader");
+    glDeleteProgram(program);
+    return false;
+  }
+
+  // Attach vertex shader to program
+  glAttachShader(program, vertShader);
+
+  // Attach fragment shader to program
+  glAttachShader(program, fragShader);
+
+  // Link program
+  if (!ndk_helper::shader::LinkProgram(program)) {
+    LOGI("Failed to link program: %d", program);
+
+    if (vertShader) {
+      glDeleteShader(vertShader);
+      vertShader = 0;
+    }
+    if (fragShader) {
+      glDeleteShader(fragShader);
+      fragShader = 0;
+    }
+    if (program) {
+      glDeleteProgram(program);
+    }
+
+    return false;
+  }
+
+  // Get uniform locations
+  params->light0_ = glGetUniformLocation(program, "vLight0");
+  params->material_ambient_ = glGetUniformLocation(program, "vMaterialAmbient");
+  params->material_specular_ =
+      glGetUniformLocation(program, "vMaterialSpecular");
+
+  // Release vertex and fragment shaders
+  if (vertShader) glDeleteShader(vertShader);
+  if (fragShader) glDeleteShader(fragShader);
+
+  params->program_ = program;
+  return true;
+}
+
+//--------------------------------------------------------------------------------
+// Bind
+//--------------------------------------------------------------------------------
+bool MoreTeapotsRenderer::Bind(ndk_helper::TapCamera* camera) {
+  camera_ = camera;
+  return true;
+}
+
+//--------------------------------------------------------------------------------
+// Helper functions
+//--------------------------------------------------------------------------------
+std::string MoreTeapotsRenderer::ToString(const int32_t i) {
+  char str[64];
+  snprintf(str, sizeof(str), "%d", i);
+  return std::string(str);
+}

MoreTeapots/app/src/main/jni/MoreTeapotsRenderer.h

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//--------------------------------------------------------------------------------
+// MoreTeapotsRenderer.h
+// Renderer for teapots
+//--------------------------------------------------------------------------------
+#ifndef _MoreTeapotsRenderer_H
+#define _MoreTeapotsRenderer_H
+
+//--------------------------------------------------------------------------------
+// Include files
+//--------------------------------------------------------------------------------
+#include <jni.h>
+#include <errno.h>
+#include <random>
+#include <vector>
+
+#include <EGL/egl.h>
+#include <GLES/gl.h>
+
+#include <android/sensor.h>
+#include <android/log.h>
+#include <android_native_app_glue.h>
+#include <android/native_window_jni.h>
+#include <cpu-features.h>
+
+#define CLASS_NAME "android/app/NativeActivity"
+#define APPLICATION_CLASS_NAME "com/sample/moreteapots/MoreTeapotsApplication"
+
+#include "NDKHelper.h"
+
+#define BUFFER_OFFSET(i) ((char*)NULL + (i))
+
+struct TEAPOT_VERTEX {
+  float pos[3];
+  float normal[3];
+};
+
+enum SHADER_ATTRIBUTES {
+  ATTRIB_VERTEX,
+  ATTRIB_NORMAL,
+  ATTRIB_COLOR,
+  ATTRIB_UV
+};
+
+struct SHADER_PARAMS {
+  GLuint program_;
+  GLuint light0_;
+  GLuint material_diffuse_;
+  GLuint material_ambient_;
+  GLuint material_specular_;
+
+  GLuint matrix_projection_;
+  GLuint matrix_view_;
+};
+
+struct TEAPOT_MATERIALS {
+  float specular_color[4];
+  float ambient_color[3];
+};
+
+class MoreTeapotsRenderer {
+  int32_t num_indices_;
+  int32_t num_vertices_;
+  GLuint ibo_;
+  GLuint vbo_;
+  GLuint ubo_;
+
+  SHADER_PARAMS shader_param_;
+  bool LoadShaders(SHADER_PARAMS* params, const char* strVsh,
+                   const char* strFsh);
+  bool LoadShadersES3(SHADER_PARAMS* params, const char* strVsh,
+                      const char* strFsh,
+                      std::map<std::string, std::string>& shaderParameters);
+
+  ndk_helper::Mat4 mat_projection_;
+  ndk_helper::Mat4 mat_view_;
+  std::vector<ndk_helper::Mat4> vec_mat_models_;
+  std::vector<ndk_helper::Vec3> vec_colors_;
+  std::vector<ndk_helper::Vec2> vec_rotations_;
+  std::vector<ndk_helper::Vec2> vec_current_rotations_;
+
+  ndk_helper::TapCamera* camera_;
+
+  int32_t teapot_x_;
+  int32_t teapot_y_;
+  int32_t teapot_z_;
+  int32_t ubo_matrix_stride_;
+  int32_t ubo_vector_stride_;
+  bool geometry_instancing_support_;
+  bool arb_support_;
+
+  std::string ToString(const int32_t i);
+
+ public:
+  MoreTeapotsRenderer();
+  virtual ~MoreTeapotsRenderer();
+  void Init(const int32_t numX, const int32_t numY, const int32_t numZ);
+  void Render();
+  void Update(float dTime);
+  bool Bind(ndk_helper::TapCamera* camera);
+  void Unload();
+  void UpdateViewport();
+};
+
+#endif

MoreTeapots/app/src/main/jni/ndk_helper/GLContext.cpp

@@ -0,0 +1,248 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//--------------------------------------------------------------------------------
+// GLContext.cpp
+//--------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------
+// includes
+//--------------------------------------------------------------------------------
+#include <unistd.h>
+#include "GLContext.h"
+#include "gl3stub.h"
+
+namespace ndk_helper {
+
+//--------------------------------------------------------------------------------
+// eGLContext
+//--------------------------------------------------------------------------------
+
+//--------------------------------------------------------------------------------
+// Ctor
+//--------------------------------------------------------------------------------
+GLContext::GLContext()
+    : display_(EGL_NO_DISPLAY),
+      surface_(EGL_NO_SURFACE),
+      context_(EGL_NO_CONTEXT),
+      screen_width_(0),
+      screen_height_(0),
+      gles_initialized_(false),
+      egl_context_initialized_(false),
+      es3_supported_(false) {}
+
+void GLContext::InitGLES() {
+  if (gles_initialized_) return;
+  //
+  // Initialize OpenGL ES 3 if available
+  //
+  const char* versionStr = (const char*)glGetString(GL_VERSION);
+  if (strstr(versionStr, "OpenGL ES 3.") && gl3stubInit()) {
+    es3_supported_ = true;
+    gl_version_ = 3.0f;
+  } else {
+    gl_version_ = 2.0f;
+  }
+
+  gles_initialized_ = true;
+}
+
+//--------------------------------------------------------------------------------
+// Dtor
+//--------------------------------------------------------------------------------
+GLContext::~GLContext() { Terminate(); }
+
+bool GLContext::Init(ANativeWindow* window) {
+  if (egl_context_initialized_) return true;
+
+  //
+  // Initialize EGL
+  //
+  window_ = window;
+  InitEGLSurface();
+  InitEGLContext();
+  InitGLES();
+
+  egl_context_initialized_ = true;
+
+  return true;
+}
+
+bool GLContext::InitEGLSurface() {
+  display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  eglInitialize(display_, 0, 0);
+
+  /*
+   * Here specify the attributes of the desired configuration.
+   * Below, we select an EGLConfig with at least 8 bits per color
+   * component compatible with on-screen windows
+   */
+  const EGLint attribs[] = {
+      EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,  // Request opengl ES2.0
+      EGL_SURFACE_TYPE,    EGL_WINDOW_BIT,     EGL_BLUE_SIZE, 8,
+      EGL_GREEN_SIZE,      8,                  EGL_RED_SIZE,  8,
+      EGL_DEPTH_SIZE,      24,                 EGL_NONE};
+  color_size_ = 8;
+  depth_size_ = 24;
+
+  EGLint num_configs;
+  eglChooseConfig(display_, attribs, &config_, 1, &num_configs);
+
+  if (!num_configs) {
+    // Fall back to 16bit depth buffer
+    const EGLint attribs[] = {
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,  // Request opengl ES2.0
+        EGL_SURFACE_TYPE,    EGL_WINDOW_BIT,     EGL_BLUE_SIZE, 8,
+        EGL_GREEN_SIZE,      8,                  EGL_RED_SIZE,  8,
+        EGL_DEPTH_SIZE,      16,                 EGL_NONE};
+    eglChooseConfig(display_, attribs, &config_, 1, &num_configs);
+    depth_size_ = 16;
+  }
+
+  if (!num_configs) {
+    LOGW("Unable to retrieve EGL config");
+    return false;
+  }
+
+  surface_ = eglCreateWindowSurface(display_, config_, window_, NULL);
+  eglQuerySurface(display_, surface_, EGL_WIDTH, &screen_width_);
+  eglQuerySurface(display_, surface_, EGL_HEIGHT, &screen_height_);
+
+  return true;
+}
+
+bool GLContext::InitEGLContext() {
+  const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION,
+                                    2,  // Request opengl ES2.0
+                                    EGL_NONE};
+  context_ = eglCreateContext(display_, config_, NULL, context_attribs);
+
+  if (eglMakeCurrent(display_, surface_, surface_, context_) == EGL_FALSE) {
+    LOGW("Unable to eglMakeCurrent");
+    return false;
+  }
+
+  context_valid_ = true;
+  return true;
+}
+
+EGLint GLContext::Swap() {
+  bool b = eglSwapBuffers(display_, surface_);
+  if (!b) {
+    EGLint err = eglGetError();
+    if (err == EGL_BAD_SURFACE) {
+      // Recreate surface
+      InitEGLSurface();
+      return EGL_SUCCESS;  // Still consider glContext is valid
+    } else if (err == EGL_CONTEXT_LOST || err == EGL_BAD_CONTEXT) {
+      // Context has been lost!!
+      context_valid_ = false;
+      Terminate();
+      InitEGLContext();
+    }
+    return err;
+  }
+  return EGL_SUCCESS;
+}
+
+void GLContext::Terminate() {
+  if (display_ != EGL_NO_DISPLAY) {
+    eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    if (context_ != EGL_NO_CONTEXT) {
+      eglDestroyContext(display_, context_);
+    }
+
+    if (surface_ != EGL_NO_SURFACE) {
+      eglDestroySurface(display_, surface_);
+    }
+    eglTerminate(display_);
+  }
+
+  display_ = EGL_NO_DISPLAY;
+  context_ = EGL_NO_CONTEXT;
+  surface_ = EGL_NO_SURFACE;
+  context_valid_ = false;
+}
+
+EGLint GLContext::Resume(ANativeWindow* window) {
+  if (egl_context_initialized_ == false) {
+    Init(window);
+    return EGL_SUCCESS;
+  }
+
+  int32_t original_widhth = screen_width_;
+  int32_t original_height = screen_height_;
+
+  // Create surface
+  window_ = window;
+  surface_ = eglCreateWindowSurface(display_, config_, window_, NULL);
+  eglQuerySurface(display_, surface_, EGL_WIDTH, &screen_width_);
+  eglQuerySurface(display_, surface_, EGL_HEIGHT, &screen_height_);
+
+  if (screen_width_ != original_widhth || screen_height_ != original_height) {
+    // Screen resized
+    LOGI("Screen resized");
+  }
+
+  if (eglMakeCurrent(display_, surface_, surface_, context_) == EGL_TRUE)
+    return EGL_SUCCESS;
+
+  EGLint err = eglGetError();
+  LOGW("Unable to eglMakeCurrent %d", err);
+
+  if (err == EGL_CONTEXT_LOST) {
+    // Recreate context
+    LOGI("Re-creating egl context");
+    InitEGLContext();
+  } else {
+    // Recreate surface
+    Terminate();
+    InitEGLSurface();
+    InitEGLContext();
+  }
+
+  return err;
+}
+
+void GLContext::Suspend() {
+  if (surface_ != EGL_NO_SURFACE) {
+    eglDestroySurface(display_, surface_);
+    surface_ = EGL_NO_SURFACE;
+  }
+}
+
+bool GLContext::Invalidate() {
+  Terminate();
+
+  egl_context_initialized_ = false;
+  return true;
+}
+
+bool GLContext::CheckExtension(const char* extension) {
+  if (extension == NULL) return false;
+
+  std::string extensions = std::string((char*)glGetString(GL_EXTENSIONS));
+  std::string str = std::string(extension);
+  str.append(" ");
+
+  size_t pos = 0;
+  if (extensions.find(extension, pos) != std::string::npos) {
+    return true;
+  }
+
+  return false;
+}
+
+}  // namespace ndkHelper

MoreTeapots/app/src/main/jni/ndk_helper/GLContext.h

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//--------------------------------------------------------------------------------
+// GLContext.h
+//--------------------------------------------------------------------------------
+#ifndef GLCONTEXT_H_
+#define GLCONTEXT_H_
+
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+#include <android/log.h>
+
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+//--------------------------------------------------------------------------------
+// Constants
+//--------------------------------------------------------------------------------
+
+//--------------------------------------------------------------------------------
+// Class
+//--------------------------------------------------------------------------------
+
+/******************************************************************
+ * OpenGL context handler
+ * The class handles OpenGL and EGL context based on Android activity life cycle
+ * The caller needs to call corresponding methods for each activity life cycle
+ *events as it's done in sample codes.
+ *
+ * Also the class initializes OpenGL ES3 when the compatible driver is installed
+ *in the device.
+ * getGLVersion() returns 3.0~ when the device supports OpenGLES3.0
+ *
+ * Thread safety: OpenGL context is expecting used within dedicated single
+ *thread,
+ * thus GLContext class is not designed as a thread-safe
+ */
+class GLContext {
+ private:
+  // EGL configurations
+  ANativeWindow* window_;
+  EGLDisplay display_;
+  EGLSurface surface_;
+  EGLContext context_;
+  EGLConfig config_;
+
+  // Screen parameters
+  int32_t screen_width_;
+  int32_t screen_height_;
+  int32_t color_size_;
+  int32_t depth_size_;
+
+  // Flags
+  bool gles_initialized_;
+  bool egl_context_initialized_;
+  bool es3_supported_;
+  float gl_version_;
+  bool context_valid_;
+
+  void InitGLES();
+  void Terminate();
+  bool InitEGLSurface();
+  bool InitEGLContext();
+
+  GLContext(GLContext const&);
+  void operator=(GLContext const&);
+  GLContext();
+  virtual ~GLContext();
+
+ public:
+  static GLContext* GetInstance() {
+    // Singleton
+    static GLContext instance;
+
+    return &instance;
+  }
+
+  bool Init(ANativeWindow* window);
+  EGLint Swap();
+  bool Invalidate();
+
+  void Suspend();
+  EGLint Resume(ANativeWindow* window);
+
+  int32_t GetScreenWidth() { return screen_width_; }
+  int32_t GetScreenHeight() { return screen_height_; }
+
+  int32_t GetBufferColorSize() { return color_size_; }
+  int32_t GetBufferDepthSize() { return depth_size_; }
+  float GetGLVersion() { return gl_version_; }
+  bool CheckExtension(const char* extension);
+};
+
+}  // namespace ndkHelper
+
+#endif /* GLCONTEXT_H_ */

MoreTeapots/app/src/main/jni/ndk_helper/JNIHelper.cpp

@@ -0,0 +1,365 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 <EGL/egl.h>
+#include <GLES2/gl2.h>
+#include <fstream>
+#include <iostream>
+
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+#define CLASS_NAME "android/app/NativeActivity"
+
+//---------------------------------------------------------------------------
+// JNI Helper functions
+//---------------------------------------------------------------------------
+
+//---------------------------------------------------------------------------
+// Singleton
+//---------------------------------------------------------------------------
+JNIHelper* JNIHelper::GetInstance() {
+  static JNIHelper helper;
+  return &helper;
+}
+
+//---------------------------------------------------------------------------
+// Ctor
+//---------------------------------------------------------------------------
+JNIHelper::JNIHelper() { pthread_mutex_init(&mutex_, NULL); }
+
+//---------------------------------------------------------------------------
+// Dtor
+//---------------------------------------------------------------------------
+JNIHelper::~JNIHelper() {
+  pthread_mutex_lock(&mutex_);
+
+  JNIEnv* env;
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  env->DeleteGlobalRef(jni_helper_java_ref_);
+  env->DeleteGlobalRef(jni_helper_java_class_);
+
+  activity_->vm->DetachCurrentThread();
+
+  pthread_mutex_destroy(&mutex_);
+}
+
+//---------------------------------------------------------------------------
+// Init
+//---------------------------------------------------------------------------
+void JNIHelper::Init(ANativeActivity* activity, const char* helper_class_name) {
+  JNIHelper& helper = *GetInstance();
+  pthread_mutex_lock(&helper.mutex_);
+
+  helper.activity_ = activity;
+
+  JNIEnv* env;
+  helper.activity_->vm->AttachCurrentThread(&env, NULL);
+
+  // Retrieve app name
+  jclass android_content_Context = env->GetObjectClass(helper.activity_->clazz);
+  jmethodID midGetPackageName = env->GetMethodID(
+      android_content_Context, "getPackageName", "()Ljava/lang/String;");
+
+  jstring packageName = (jstring)env->CallObjectMethod(helper.activity_->clazz,
+                                                       midGetPackageName);
+  const char* appname = env->GetStringUTFChars(packageName, NULL);
+  helper.app_name_ = std::string(appname);
+
+  jclass cls = helper.RetrieveClass(env, helper_class_name);
+  helper.jni_helper_java_class_ = (jclass)env->NewGlobalRef(cls);
+
+  jmethodID constructor =
+      env->GetMethodID(helper.jni_helper_java_class_, "<init>", "()V");
+  helper.jni_helper_java_ref_ =
+      env->NewObject(helper.jni_helper_java_class_, constructor);
+  helper.jni_helper_java_ref_ = env->NewGlobalRef(helper.jni_helper_java_ref_);
+
+  env->ReleaseStringUTFChars(packageName, appname);
+  helper.activity_->vm->DetachCurrentThread();
+
+  pthread_mutex_unlock(&helper.mutex_);
+}
+
+//---------------------------------------------------------------------------
+// readFile
+//---------------------------------------------------------------------------
+bool JNIHelper::ReadFile(const char* fileName,
+                         std::vector<uint8_t>* buffer_ref) {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized.Call init() to initialize the "
+        "helper");
+    return false;
+  }
+
+  // First, try reading from externalFileDir;
+  JNIEnv* env;
+
+  pthread_mutex_lock(&mutex_);
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  jstring str_path = GetExternalFilesDirJString(env);
+  const char* path = env->GetStringUTFChars(str_path, NULL);
+  std::string s(path);
+
+  if (fileName[0] != '/') {
+    s.append("/");
+  }
+  s.append(fileName);
+  std::ifstream f(s.c_str(), std::ios::binary);
+
+  env->ReleaseStringUTFChars(str_path, path);
+  env->DeleteLocalRef(str_path);
+  activity_->vm->DetachCurrentThread();
+
+  if (f) {
+    LOGI("reading:%s", s.c_str());
+    f.seekg(0, std::ifstream::end);
+    int32_t fileSize = f.tellg();
+    f.seekg(0, std::ifstream::beg);
+    buffer_ref->reserve(fileSize);
+    buffer_ref->assign(std::istreambuf_iterator<char>(f),
+                       std::istreambuf_iterator<char>());
+    f.close();
+    pthread_mutex_unlock(&mutex_);
+    return true;
+  } else {
+    // Fallback to assetManager
+    AAssetManager* assetManager = activity_->assetManager;
+    AAsset* assetFile =
+        AAssetManager_open(assetManager, fileName, AASSET_MODE_BUFFER);
+    if (!assetFile) {
+      pthread_mutex_unlock(&mutex_);
+      return false;
+    }
+    uint8_t* data = (uint8_t*)AAsset_getBuffer(assetFile);
+    int32_t size = AAsset_getLength(assetFile);
+    if (data == NULL) {
+      AAsset_close(assetFile);
+
+      LOGI("Failed to load:%s", fileName);
+      pthread_mutex_unlock(&mutex_);
+      return false;
+    }
+
+    buffer_ref->reserve(size);
+    buffer_ref->assign(data, data + size);
+
+    AAsset_close(assetFile);
+    pthread_mutex_unlock(&mutex_);
+    return true;
+  }
+}
+
+std::string JNIHelper::GetExternalFilesDir() {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return std::string("");
+  }
+
+  pthread_mutex_lock(&mutex_);
+
+  // First, try reading from externalFileDir;
+  JNIEnv* env;
+
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  jstring strPath = GetExternalFilesDirJString(env);
+  const char* path = env->GetStringUTFChars(strPath, NULL);
+  std::string s(path);
+
+  env->ReleaseStringUTFChars(strPath, path);
+  env->DeleteLocalRef(strPath);
+  activity_->vm->DetachCurrentThread();
+
+  pthread_mutex_unlock(&mutex_);
+  return s;
+}
+
+uint32_t JNIHelper::LoadTexture(const char* file_name) {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return 0;
+  }
+
+  JNIEnv* env;
+  jmethodID mid;
+
+  pthread_mutex_lock(&mutex_);
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  jstring name = env->NewStringUTF(file_name);
+
+  GLuint tex;
+  glGenTextures(1, &tex);
+  glBindTexture(GL_TEXTURE_2D, tex);
+
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                  GL_LINEAR_MIPMAP_NEAREST);
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+  mid = env->GetMethodID(jni_helper_java_class_, "loadTexture",
+                         "(Ljava/lang/String;)Z");
+  jboolean ret = env->CallBooleanMethod(jni_helper_java_ref_, mid, name);
+  if (!ret) {
+    glDeleteTextures(1, &tex);
+    tex = -1;
+    LOGI("Texture load failed %s", file_name);
+  }
+
+  // Generate mipmap
+  glGenerateMipmap(GL_TEXTURE_2D);
+
+  env->DeleteLocalRef(name);
+  activity_->vm->DetachCurrentThread();
+  pthread_mutex_unlock(&mutex_);
+
+  return tex;
+}
+
+std::string JNIHelper::ConvertString(const char* str, const char* encode) {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return std::string("");
+  }
+
+  JNIEnv* env;
+
+  pthread_mutex_lock(&mutex_);
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  int32_t iLength = strlen((const char*)str);
+
+  jbyteArray array = env->NewByteArray(iLength);
+  env->SetByteArrayRegion(array, 0, iLength, (const signed char*)str);
+
+  jstring strEncode = env->NewStringUTF(encode);
+
+  jclass cls = env->FindClass("java/lang/String");
+  jmethodID ctor = env->GetMethodID(cls, "<init>", "([BLjava/lang/String;)V");
+  jstring object = (jstring)env->NewObject(cls, ctor, array, strEncode);
+
+  const char* cparam = env->GetStringUTFChars(object, NULL);
+
+  std::string s = std::string(cparam);
+
+  env->ReleaseStringUTFChars(object, cparam);
+  env->DeleteLocalRef(strEncode);
+  env->DeleteLocalRef(object);
+  activity_->vm->DetachCurrentThread();
+  pthread_mutex_unlock(&mutex_);
+
+  return s;
+}
+
+//---------------------------------------------------------------------------
+// Audio helpers
+//---------------------------------------------------------------------------
+int32_t JNIHelper::GetNativeAudioBufferSize() {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return 0;
+  }
+
+  JNIEnv* env;
+  jmethodID mid;
+
+  pthread_mutex_lock(&mutex_);
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  mid = env->GetMethodID(jni_helper_java_class_, "getNativeAudioBufferSize",
+                         "()I");
+  int32_t i = env->CallIntMethod(jni_helper_java_ref_, mid);
+  activity_->vm->DetachCurrentThread();
+  pthread_mutex_unlock(&mutex_);
+
+  return i;
+}
+
+int32_t JNIHelper::GetNativeAudioSampleRate() {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return 0;
+  }
+
+  JNIEnv* env;
+  jmethodID mid;
+
+  pthread_mutex_lock(&mutex_);
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  mid = env->GetMethodID(jni_helper_java_class_, "getNativeAudioSampleRate",
+                         "()I");
+  int32_t i = env->CallIntMethod(jni_helper_java_ref_, mid);
+  activity_->vm->DetachCurrentThread();
+  pthread_mutex_unlock(&mutex_);
+
+  return i;
+}
+
+//---------------------------------------------------------------------------
+// Misc implementations
+//---------------------------------------------------------------------------
+jclass JNIHelper::RetrieveClass(JNIEnv* jni, const char* class_name) {
+  jclass activity_class = jni->FindClass(CLASS_NAME);
+  jmethodID get_class_loader = jni->GetMethodID(
+      activity_class, "getClassLoader", "()Ljava/lang/ClassLoader;");
+  jobject cls = jni->CallObjectMethod(activity_->clazz, get_class_loader);
+  jclass class_loader = jni->FindClass("java/lang/ClassLoader");
+  jmethodID find_class = jni->GetMethodID(
+      class_loader, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
+
+  jstring str_class_name = jni->NewStringUTF(class_name);
+  jclass class_retrieved =
+      (jclass)jni->CallObjectMethod(cls, find_class, str_class_name);
+  jni->DeleteLocalRef(str_class_name);
+  return class_retrieved;
+}
+
+jstring JNIHelper::GetExternalFilesDirJString(JNIEnv* env) {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return NULL;
+  }
+
+  // Invoking getExternalFilesDir() java API
+  jclass cls_Env = env->FindClass(CLASS_NAME);
+  jmethodID mid = env->GetMethodID(cls_Env, "getExternalFilesDir",
+                                   "(Ljava/lang/String;)Ljava/io/File;");
+  jobject obj_File = env->CallObjectMethod(activity_->clazz, mid, NULL);
+  jclass cls_File = env->FindClass("java/io/File");
+  jmethodID mid_getPath =
+      env->GetMethodID(cls_File, "getPath", "()Ljava/lang/String;");
+  jstring obj_Path = (jstring)env->CallObjectMethod(obj_File, mid_getPath);
+
+  return obj_Path;
+}
+
+}  // namespace ndkHelper

MoreTeapots/app/src/main/jni/ndk_helper/JNIHelper.h

@@ -0,0 +1,183 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <jni.h>
+#include <vector>
+#include <string>
+
+#include <android/log.h>
+#include <android_native_app_glue.h>
+
+#define LOGI(...)                                                           \
+  ((void)__android_log_print(                                               \
+      ANDROID_LOG_INFO, ndk_helper::JNIHelper::GetInstance()->GetAppName(), \
+      __VA_ARGS__))
+#define LOGW(...)                                                           \
+  ((void)__android_log_print(                                               \
+      ANDROID_LOG_WARN, ndk_helper::JNIHelper::GetInstance()->GetAppName(), \
+      __VA_ARGS__))
+#define LOGE(...)                                                            \
+  ((void)__android_log_print(                                                \
+      ANDROID_LOG_ERROR, ndk_helper::JNIHelper::GetInstance()->GetAppName(), \
+      __VA_ARGS__))
+
+namespace ndk_helper {
+
+/******************************************************************
+ * Helper functions for JNI calls
+ * This class wraps JNI calls and provides handy interface calling commonly used
+ *features
+ * in Java SDK.
+ * Such as
+ * - loading graphics files (e.g. PNG, JPG)
+ * - character code conversion
+ * - retrieving system properties which only supported in Java SDK
+ *
+ * NOTE: To use this class, add NDKHelper.java as a corresponding helpers in
+ *Java code
+ */
+class JNIHelper {
+ private:
+  std::string app_name_;
+
+  ANativeActivity* activity_;
+  jobject jni_helper_java_ref_;
+  jclass jni_helper_java_class_;
+
+  // mutex for synchronization
+  // This class uses singleton pattern and can be invoked from multiple threads,
+  // each methods locks the mutex for a thread safety
+  mutable pthread_mutex_t mutex_;
+
+  jstring GetExternalFilesDirJString(JNIEnv* env);
+  jclass RetrieveClass(JNIEnv* jni, const char* class_name);
+
+  JNIHelper();
+  ~JNIHelper();
+  JNIHelper(const JNIHelper& rhs);
+  JNIHelper& operator=(const JNIHelper& rhs);
+
+ public:
+  /*
+   * To load your own Java classes, JNIHelper requires to be initialized with a
+   *ANativeActivity handle.
+   * This methods need to be called before any call to the helper class.
+   * Static member of the class
+   *
+   * arguments:
+   * in: activity, pointer to ANativeActivity. Used internally to set up JNI
+   *environment
+   * in: helper_class_name, pointer to Java side helper class name. (e.g.
+   *"com/sample/helper/NDKHelper" in samples )
+   */
+  static void Init(ANativeActivity* activity, const char* helper_class_name);
+
+  /*
+   * Retrieve the singleton object of the helper.
+   * Static member of the class
+
+   * Methods in the class are designed as thread safe.
+   */
+  static JNIHelper* GetInstance();
+
+  /*
+   * Read a file from a strorage.
+   * First, the method tries to read the file from an external storage.
+   * If it fails to read, it falls back to use assset manager and try to read
+   *the file from APK asset.
+   *
+   * arguments:
+   * in: file_name, file name to read
+   * out: buffer_ref, pointer to a vector buffer to read a file.
+   *      when the call succeeded, the buffer includes contents of specified
+   *file
+   *      when the call failed, contents of the buffer remains same
+   * return:
+   * true when file read succeeded
+   * false when it failed to read the file
+   */
+  bool ReadFile(const char* file_name, std::vector<uint8_t>* buffer_ref);
+
+  /*
+   * Load and create OpenGL texture from given file name.
+   * The method invokes BitmapFactory in Java so it can read jpeg/png formatted
+   *files
+   *
+   * The methods creates mip-map and set texture parameters like this,
+   * glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+   *GL_LINEAR_MIPMAP_NEAREST );
+   * glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+   * glGenerateMipmap( GL_TEXTURE_2D );
+   *
+   * arguments:
+   * in: file_name, file name to read, PNG&JPG is supported
+   * return:
+   * OpenGL texture name when the call succeeded
+   * When it failed to load the texture, it returns -1
+   */
+  uint32_t LoadTexture(const char* file_name);
+
+  /*
+   * Convert string from character code other than UTF-8
+   *
+   * arguments:
+   *  in: str, pointer to a string which is encoded other than UTF-8
+   *  in: encoding, pointer to a character encoding string.
+   *  The encoding string can be any valid java.nio.charset.Charset name
+   *  e.g. "UTF-16", "Shift_JIS"
+   * return: converted input string as an UTF-8 std::string
+   */
+  std::string ConvertString(const char* str, const char* encode);
+  /*
+   * Retrieve external file directory through JNI call
+   *
+   * return: std::string containing external file diretory
+   */
+  std::string GetExternalFilesDir();
+
+  /*
+   * Audio helper
+   * Retrieves native audio buffer size which is required to achieve low latency
+   *audio
+   *
+   * return: Native audio buffer size which is a hint to achieve low latency
+   *audio
+   * If the API is not supported (API level < 17), it returns 0
+   */
+  int32_t GetNativeAudioBufferSize();
+
+  /*
+   * Audio helper
+   * Retrieves native audio sample rate which is required to achieve low latency
+   *audio
+   *
+   * return: Native audio sample rate which is a hint to achieve low latency
+   *audio
+   */
+  int32_t GetNativeAudioSampleRate();
+
+  /*
+   * Retrieves application bundle name
+   *
+   * return: pointer to an app name string
+   *
+   */
+  const char* GetAppName() { return app_name_.c_str(); }
+};
+
+}  // namespace ndkHelper

MoreTeapots/app/src/main/jni/ndk_helper/NDKHelper.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 _NDKSUPPORT_H
+#define _NDKSUPPORT_H
+
+/******************************************************************
+ * NDK support helpers
+ * Utility module to provide misc functionalities that is used widely in native
+ *applications,
+ * such as gesture detection, jni bridge, openGL context etc.
+ *
+ * The purpose of this module is,
+ * - Provide best practices using NDK
+ * - Provide handy utility functions for NDK development
+ * - Make NDK samples more simpler and readable
+ */
+#include "gl3stub.h"    //GLES3 stubs
+#include "GLContext.h"  //EGL & OpenGL manager
+#include "shader.h"     //Shader compiler support
+#include "vecmath.h"  //Vector math support, C++ implementation n current version
+#include "tapCamera.h"        //Tap/Pinch camera control
+#include "JNIHelper.h"        //JNI support
+#include "gestureDetector.h"  //Tap/Doubletap/Pinch detector
+#include "perfMonitor.h"      //FPS counter
+#include "interpolator.h"     //Interpolator
+#endif

MoreTeapots/app/src/main/jni/ndk_helper/gestureDetector.cpp

@@ -0,0 +1,296 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 "gestureDetector.h"
+
+//--------------------------------------------------------------------------------
+// gestureDetector.cpp
+//--------------------------------------------------------------------------------
+namespace ndk_helper {
+
+//--------------------------------------------------------------------------------
+// includes
+//--------------------------------------------------------------------------------
+
+//--------------------------------------------------------------------------------
+// GestureDetector
+//--------------------------------------------------------------------------------
+GestureDetector::GestureDetector() { dp_factor_ = 1.f; }
+
+void GestureDetector::SetConfiguration(AConfiguration* config) {
+  dp_factor_ = 160.f / AConfiguration_getDensity(config);
+}
+
+//--------------------------------------------------------------------------------
+// TapDetector
+//--------------------------------------------------------------------------------
+GESTURE_STATE TapDetector::Detect(const AInputEvent* motion_event) {
+  if (AMotionEvent_getPointerCount(motion_event) > 1) {
+    // Only support single touch
+    return false;
+  }
+
+  int32_t action = AMotionEvent_getAction(motion_event);
+  unsigned int flags = action & AMOTION_EVENT_ACTION_MASK;
+  switch (flags) {
+    case AMOTION_EVENT_ACTION_DOWN:
+      down_pointer_id_ = AMotionEvent_getPointerId(motion_event, 0);
+      down_x_ = AMotionEvent_getX(motion_event, 0);
+      down_y_ = AMotionEvent_getY(motion_event, 0);
+      break;
+    case AMOTION_EVENT_ACTION_UP: {
+      int64_t eventTime = AMotionEvent_getEventTime(motion_event);
+      int64_t downTime = AMotionEvent_getDownTime(motion_event);
+      if (eventTime - downTime <= TAP_TIMEOUT) {
+        if (down_pointer_id_ == AMotionEvent_getPointerId(motion_event, 0)) {
+          float x = AMotionEvent_getX(motion_event, 0) - down_x_;
+          float y = AMotionEvent_getY(motion_event, 0) - down_y_;
+          if (x * x + y * y < TOUCH_SLOP * TOUCH_SLOP * dp_factor_) {
+            LOGI("TapDetector: Tap detected");
+            return GESTURE_STATE_ACTION;
+          }
+        }
+      }
+      break;
+    }
+  }
+  return GESTURE_STATE_NONE;
+}
+
+//--------------------------------------------------------------------------------
+// DoubletapDetector
+//--------------------------------------------------------------------------------
+GESTURE_STATE DoubletapDetector::Detect(const AInputEvent* motion_event) {
+  if (AMotionEvent_getPointerCount(motion_event) > 1) {
+    // Only support single double tap
+    return false;
+  }
+
+  bool tap_detected = tap_detector_.Detect(motion_event);
+
+  int32_t action = AMotionEvent_getAction(motion_event);
+  unsigned int flags = action & AMOTION_EVENT_ACTION_MASK;
+  switch (flags) {
+    case AMOTION_EVENT_ACTION_DOWN: {
+      int64_t eventTime = AMotionEvent_getEventTime(motion_event);
+      if (eventTime - last_tap_time_ <= DOUBLE_TAP_TIMEOUT) {
+        float x = AMotionEvent_getX(motion_event, 0) - last_tap_x_;
+        float y = AMotionEvent_getY(motion_event, 0) - last_tap_y_;
+        if (x * x + y * y < DOUBLE_TAP_SLOP * DOUBLE_TAP_SLOP * dp_factor_) {
+          LOGI("DoubletapDetector: Doubletap detected");
+          return GESTURE_STATE_ACTION;
+        }
+      }
+      break;
+    }
+    case AMOTION_EVENT_ACTION_UP:
+      if (tap_detected) {
+        last_tap_time_ = AMotionEvent_getEventTime(motion_event);
+        last_tap_x_ = AMotionEvent_getX(motion_event, 0);
+        last_tap_y_ = AMotionEvent_getY(motion_event, 0);
+      }
+      break;
+  }
+  return GESTURE_STATE_NONE;
+}
+
+void DoubletapDetector::SetConfiguration(AConfiguration* config) {
+  dp_factor_ = 160.f / AConfiguration_getDensity(config);
+  tap_detector_.SetConfiguration(config);
+}
+
+//--------------------------------------------------------------------------------
+// PinchDetector
+//--------------------------------------------------------------------------------
+
+int32_t PinchDetector::FindIndex(const AInputEvent* event, int32_t id) {
+  int32_t count = AMotionEvent_getPointerCount(event);
+  for (auto i = 0; i < count; ++i) {
+    if (id == AMotionEvent_getPointerId(event, i)) return i;
+  }
+  return -1;
+}
+
+GESTURE_STATE PinchDetector::Detect(const AInputEvent* event) {
+  GESTURE_STATE ret = GESTURE_STATE_NONE;
+  int32_t action = AMotionEvent_getAction(event);
+  uint32_t flags = action & AMOTION_EVENT_ACTION_MASK;
+  event_ = event;
+
+  int32_t count = AMotionEvent_getPointerCount(event);
+  switch (flags) {
+    case AMOTION_EVENT_ACTION_DOWN:
+      vec_pointers_.push_back(AMotionEvent_getPointerId(event, 0));
+      break;
+    case AMOTION_EVENT_ACTION_POINTER_DOWN: {
+      int32_t iIndex = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
+                       AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
+      vec_pointers_.push_back(AMotionEvent_getPointerId(event, iIndex));
+      if (count == 2) {
+        // Start new pinch
+        ret = GESTURE_STATE_START;
+      }
+    } break;
+    case AMOTION_EVENT_ACTION_UP:
+      vec_pointers_.pop_back();
+      break;
+    case AMOTION_EVENT_ACTION_POINTER_UP: {
+      int32_t index = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
+                      AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
+      int32_t released_pointer_id = AMotionEvent_getPointerId(event, index);
+
+      std::vector<int32_t>::iterator it = vec_pointers_.begin();
+      std::vector<int32_t>::iterator it_end = vec_pointers_.end();
+      int32_t i = 0;
+      for (; it != it_end; ++it, ++i) {
+        if (*it == released_pointer_id) {
+          vec_pointers_.erase(it);
+          break;
+        }
+      }
+
+      if (i <= 1) {
+        // Reset pinch or drag
+        if (count != 2) {
+          // Start new pinch
+          ret = GESTURE_STATE_START | GESTURE_STATE_END;
+        }
+      }
+    } break;
+    case AMOTION_EVENT_ACTION_MOVE:
+      switch (count) {
+        case 1:
+          break;
+        default:
+          // Multi touch
+          ret = GESTURE_STATE_MOVE;
+          break;
+      }
+      break;
+    case AMOTION_EVENT_ACTION_CANCEL:
+      break;
+  }
+
+  return ret;
+}
+
+bool PinchDetector::GetPointers(Vec2& v1, Vec2& v2) {
+  if (vec_pointers_.size() < 2) return false;
+
+  int32_t index = FindIndex(event_, vec_pointers_[0]);
+  if (index == -1) return false;
+
+  float x = AMotionEvent_getX(event_, index);
+  float y = AMotionEvent_getY(event_, index);
+
+  index = FindIndex(event_, vec_pointers_[1]);
+  if (index == -1) return false;
+
+  float x2 = AMotionEvent_getX(event_, index);
+  float y2 = AMotionEvent_getY(event_, index);
+
+  v1 = Vec2(x, y);
+  v2 = Vec2(x2, y2);
+
+  return true;
+}
+
+//--------------------------------------------------------------------------------
+// DragDetector
+//--------------------------------------------------------------------------------
+
+int32_t DragDetector::FindIndex(const AInputEvent* event, int32_t id) {
+  int32_t count = AMotionEvent_getPointerCount(event);
+  for (auto i = 0; i < count; ++i) {
+    if (id == AMotionEvent_getPointerId(event, i)) return i;
+  }
+  return -1;
+}
+
+GESTURE_STATE DragDetector::Detect(const AInputEvent* event) {
+  GESTURE_STATE ret = GESTURE_STATE_NONE;
+  int32_t action = AMotionEvent_getAction(event);
+  int32_t index = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
+                  AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
+  uint32_t flags = action & AMOTION_EVENT_ACTION_MASK;
+  event_ = event;
+
+  int32_t count = AMotionEvent_getPointerCount(event);
+  switch (flags) {
+    case AMOTION_EVENT_ACTION_DOWN:
+      vec_pointers_.push_back(AMotionEvent_getPointerId(event, 0));
+      ret = GESTURE_STATE_START;
+      break;
+    case AMOTION_EVENT_ACTION_POINTER_DOWN:
+      vec_pointers_.push_back(AMotionEvent_getPointerId(event, index));
+      break;
+    case AMOTION_EVENT_ACTION_UP:
+      vec_pointers_.pop_back();
+      ret = GESTURE_STATE_END;
+      break;
+    case AMOTION_EVENT_ACTION_POINTER_UP: {
+      int32_t released_pointer_id = AMotionEvent_getPointerId(event, index);
+
+      auto it = vec_pointers_.begin();
+      auto it_end = vec_pointers_.end();
+      int32_t i = 0;
+      for (; it != it_end; ++it, ++i) {
+        if (*it == released_pointer_id) {
+          vec_pointers_.erase(it);
+          break;
+        }
+      }
+
+      if (i <= 1) {
+        // Reset pinch or drag
+        if (count == 2) {
+          ret = GESTURE_STATE_START;
+        }
+      }
+      break;
+    }
+    case AMOTION_EVENT_ACTION_MOVE:
+      switch (count) {
+        case 1:
+          // Drag
+          ret = GESTURE_STATE_MOVE;
+          break;
+        default:
+          break;
+      }
+      break;
+    case AMOTION_EVENT_ACTION_CANCEL:
+      break;
+  }
+
+  return ret;
+}
+
+bool DragDetector::GetPointer(Vec2& v) {
+  if (vec_pointers_.size() < 1) return false;
+
+  int32_t iIndex = FindIndex(event_, vec_pointers_[0]);
+  if (iIndex == -1) return false;
+
+  float x = AMotionEvent_getX(event_, iIndex);
+  float y = AMotionEvent_getY(event_, iIndex);
+
+  v = Vec2(x, y);
+
+  return true;
+}
+
+}  // namespace ndkHelper

MoreTeapots/app/src/main/jni/ndk_helper/gestureDetector.h

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//--------------------------------------------------------------------------------
+// gestureDetector.h
+//--------------------------------------------------------------------------------
+#ifndef GESTUREDETECTOR_H_
+#define GESTUREDETECTOR_H_
+
+#include <vector>
+
+#include <android/sensor.h>
+#include <android/log.h>
+#include <android_native_app_glue.h>
+#include <android/native_window_jni.h>
+#include "JNIHelper.h"
+#include "vecmath.h"
+
+namespace ndk_helper {
+//--------------------------------------------------------------------------------
+// Constants
+//--------------------------------------------------------------------------------
+const int32_t DOUBLE_TAP_TIMEOUT = 300 * 1000000;
+const int32_t TAP_TIMEOUT = 180 * 1000000;
+const int32_t DOUBLE_TAP_SLOP = 100;
+const int32_t TOUCH_SLOP = 8;
+
+enum {
+  GESTURE_STATE_NONE = 0,
+  GESTURE_STATE_START = 1,
+  GESTURE_STATE_MOVE = 2,
+  GESTURE_STATE_END = 4,
+  GESTURE_STATE_ACTION = (GESTURE_STATE_START | GESTURE_STATE_END),
+};
+typedef int32_t GESTURE_STATE;
+
+/******************************************************************
+ * Base class of Gesture Detectors
+ * GestureDetectors handles input events and detect gestures
+ * Note that different detectors may detect gestures with an event at
+ * same time. The caller needs to manage gesture priority accordingly
+ *
+ */
+class GestureDetector {
+ protected:
+  float dp_factor_;
+
+ public:
+  GestureDetector();
+  virtual ~GestureDetector() {}
+  virtual void SetConfiguration(AConfiguration* config);
+
+  virtual GESTURE_STATE Detect(const AInputEvent* motion_event) = 0;
+};
+
+/******************************************************************
+ * Tap gesture detector
+ * Returns GESTURE_STATE_ACTION when a tap gesture is detected
+ *
+ */
+class TapDetector : public GestureDetector {
+ private:
+  int32_t down_pointer_id_;
+  float down_x_;
+  float down_y_;
+
+ public:
+  TapDetector() {}
+  virtual ~TapDetector() {}
+  virtual GESTURE_STATE Detect(const AInputEvent* motion_event);
+};
+
+/******************************************************************
+ * Pinch gesture detector
+ * Returns GESTURE_STATE_ACTION when a double-tap gesture is detected
+ *
+ */
+class DoubletapDetector : public GestureDetector {
+ private:
+  TapDetector tap_detector_;
+  int64_t last_tap_time_;
+  float last_tap_x_;
+  float last_tap_y_;
+
+ public:
+  DoubletapDetector() {}
+  virtual ~DoubletapDetector() {}
+  virtual GESTURE_STATE Detect(const AInputEvent* motion_event);
+  virtual void SetConfiguration(AConfiguration* config);
+};
+
+/******************************************************************
+ * Double gesture detector
+ * Returns pinch gesture state when a pinch gesture is detected
+ * The class handles multiple touches more than 2
+ * When the finger 1,2,3 are tapped and then finger 1 is released,
+ * the detector start new pinch gesture with finger 2 & 3.
+ */
+class PinchDetector : public GestureDetector {
+ private:
+  int32_t FindIndex(const AInputEvent* event, int32_t id);
+  const AInputEvent* event_;
+  std::vector<int32_t> vec_pointers_;
+
+ public:
+  PinchDetector() {}
+  virtual ~PinchDetector() {}
+  virtual GESTURE_STATE Detect(const AInputEvent* event);
+  bool GetPointers(Vec2& v1, Vec2& v2);
+};
+
+/******************************************************************
+ * Drag gesture detector
+ * Returns drag gesture state when a drag-tap gesture is detected
+ *
+ */
+class DragDetector : public GestureDetector {
+ private:
+  int32_t FindIndex(const AInputEvent* event, int32_t id);
+  const AInputEvent* event_;
+  std::vector<int32_t> vec_pointers_;
+
+ public:
+  DragDetector() {}
+  virtual ~DragDetector() {}
+  virtual GESTURE_STATE Detect(const AInputEvent* event);
+  bool GetPointer(Vec2& v);
+};
+
+}  // namespace ndkHelper
+#endif /* GESTUREDETECTOR_H_ */

MoreTeapots/app/src/main/jni/ndk_helper/gl3stub.c

@@ -0,0 +1,512 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 <EGL/egl.h>
+#include "gl3stub.h"
+
+GLboolean gl3stubInit()
+{
+#define FIND_PROC(s) s = (void*)eglGetProcAddress(#s);
+    FIND_PROC( glReadBuffer );
+    FIND_PROC( glDrawRangeElements );
+    FIND_PROC( glTexImage3D );
+    FIND_PROC( glTexSubImage3D );
+    FIND_PROC( glCopyTexSubImage3D );
+    FIND_PROC( glCompressedTexImage3D );
+    FIND_PROC( glCompressedTexSubImage3D );
+    FIND_PROC( glGenQueries );
+    FIND_PROC( glDeleteQueries );
+    FIND_PROC( glIsQuery );
+    FIND_PROC( glBeginQuery );
+    FIND_PROC( glEndQuery );
+    FIND_PROC( glGetQueryiv );
+    FIND_PROC( glGetQueryObjectuiv );
+    FIND_PROC( glUnmapBuffer );
+    FIND_PROC( glGetBufferPointerv );
+    FIND_PROC( glDrawBuffers );
+    FIND_PROC( glUniformMatrix2x3fv );
+    FIND_PROC( glUniformMatrix3x2fv );
+    FIND_PROC( glUniformMatrix2x4fv );
+    FIND_PROC( glUniformMatrix4x2fv );
+    FIND_PROC( glUniformMatrix3x4fv );
+    FIND_PROC( glUniformMatrix4x3fv );
+    FIND_PROC( glBlitFramebuffer );
+    FIND_PROC( glRenderbufferStorageMultisample );
+    FIND_PROC( glFramebufferTextureLayer );
+    FIND_PROC( glMapBufferRange );
+    FIND_PROC( glFlushMappedBufferRange );
+    FIND_PROC( glBindVertexArray );
+    FIND_PROC( glDeleteVertexArrays );
+    FIND_PROC( glGenVertexArrays );
+    FIND_PROC( glIsVertexArray );
+    FIND_PROC( glGetIntegeri_v );
+    FIND_PROC( glBeginTransformFeedback );
+    FIND_PROC( glEndTransformFeedback );
+    FIND_PROC( glBindBufferRange );
+    FIND_PROC( glBindBufferBase );
+    FIND_PROC( glTransformFeedbackVaryings );
+    FIND_PROC( glGetTransformFeedbackVarying );
+    FIND_PROC( glVertexAttribIPointer );
+    FIND_PROC( glGetVertexAttribIiv );
+    FIND_PROC( glGetVertexAttribIuiv );
+    FIND_PROC( glVertexAttribI4i );
+    FIND_PROC( glVertexAttribI4ui );
+    FIND_PROC( glVertexAttribI4iv );
+    FIND_PROC( glVertexAttribI4uiv );
+    FIND_PROC( glGetUniformuiv );
+    FIND_PROC( glGetFragDataLocation );
+    FIND_PROC( glUniform1ui );
+    FIND_PROC( glUniform2ui );
+    FIND_PROC( glUniform3ui );
+    FIND_PROC( glUniform4ui );
+    FIND_PROC( glUniform1uiv );
+    FIND_PROC( glUniform2uiv );
+    FIND_PROC( glUniform3uiv );
+    FIND_PROC( glUniform4uiv );
+    FIND_PROC( glClearBufferiv );
+    FIND_PROC( glClearBufferuiv );
+    FIND_PROC( glClearBufferfv );
+    FIND_PROC( glClearBufferfi );
+    FIND_PROC( glGetStringi );
+    FIND_PROC( glCopyBufferSubData );
+    FIND_PROC( glGetUniformIndices );
+    FIND_PROC( glGetActiveUniformsiv );
+    FIND_PROC( glGetUniformBlockIndex );
+    FIND_PROC( glGetActiveUniformBlockiv );
+    FIND_PROC( glGetActiveUniformBlockName );
+    FIND_PROC( glUniformBlockBinding );
+    FIND_PROC( glDrawArraysInstanced );
+    FIND_PROC( glDrawElementsInstanced );
+    FIND_PROC( glFenceSync );
+    FIND_PROC( glIsSync );
+    FIND_PROC( glDeleteSync );
+    FIND_PROC( glClientWaitSync );
+    FIND_PROC( glWaitSync );
+    FIND_PROC( glGetInteger64v );
+    FIND_PROC( glGetSynciv );
+    FIND_PROC( glGetInteger64i_v );
+    FIND_PROC( glGetBufferParameteri64v );
+    FIND_PROC( glGenSamplers );
+    FIND_PROC( glDeleteSamplers );
+    FIND_PROC( glIsSampler );
+    FIND_PROC( glBindSampler );
+    FIND_PROC( glSamplerParameteri );
+    FIND_PROC( glSamplerParameteriv );
+    FIND_PROC( glSamplerParameterf );
+    FIND_PROC( glSamplerParameterfv );
+    FIND_PROC( glGetSamplerParameteriv );
+    FIND_PROC( glGetSamplerParameterfv );
+    FIND_PROC( glVertexAttribDivisor );
+    FIND_PROC( glBindTransformFeedback );
+    FIND_PROC( glDeleteTransformFeedbacks );
+    FIND_PROC( glGenTransformFeedbacks );
+    FIND_PROC( glIsTransformFeedback );
+    FIND_PROC( glPauseTransformFeedback );
+    FIND_PROC( glResumeTransformFeedback );
+    FIND_PROC( glGetProgramBinary );
+    FIND_PROC( glProgramBinary );
+    FIND_PROC( glProgramParameteri );
+    FIND_PROC( glInvalidateFramebuffer );
+    FIND_PROC( glInvalidateSubFramebuffer );
+    FIND_PROC( glTexStorage2D );
+    FIND_PROC( glTexStorage3D );
+    FIND_PROC( glGetInternalformativ );
+#undef FIND_PROC
+
+    if( !glReadBuffer || !glDrawRangeElements || !glTexImage3D || !glTexSubImage3D
+            || !glCopyTexSubImage3D || !glCompressedTexImage3D
+            || !glCompressedTexSubImage3D || !glGenQueries || !glDeleteQueries
+            || !glIsQuery || !glBeginQuery || !glEndQuery || !glGetQueryiv
+            || !glGetQueryObjectuiv || !glUnmapBuffer || !glGetBufferPointerv
+            || !glDrawBuffers || !glUniformMatrix2x3fv || !glUniformMatrix3x2fv
+            || !glUniformMatrix2x4fv || !glUniformMatrix4x2fv || !glUniformMatrix3x4fv
+            || !glUniformMatrix4x3fv || !glBlitFramebuffer
+            || !glRenderbufferStorageMultisample || !glFramebufferTextureLayer
+            || !glMapBufferRange || !glFlushMappedBufferRange || !glBindVertexArray
+            || !glDeleteVertexArrays || !glGenVertexArrays || !glIsVertexArray
+            || !glGetIntegeri_v || !glBeginTransformFeedback || !glEndTransformFeedback
+            || !glBindBufferRange || !glBindBufferBase || !glTransformFeedbackVaryings
+            || !glGetTransformFeedbackVarying || !glVertexAttribIPointer
+            || !glGetVertexAttribIiv || !glGetVertexAttribIuiv || !glVertexAttribI4i
+            || !glVertexAttribI4ui || !glVertexAttribI4iv || !glVertexAttribI4uiv
+            || !glGetUniformuiv || !glGetFragDataLocation || !glUniform1ui
+            || !glUniform2ui || !glUniform3ui || !glUniform4ui || !glUniform1uiv
+            || !glUniform2uiv || !glUniform3uiv || !glUniform4uiv || !glClearBufferiv
+            || !glClearBufferuiv || !glClearBufferfv || !glClearBufferfi || !glGetStringi
+            || !glCopyBufferSubData || !glGetUniformIndices || !glGetActiveUniformsiv
+            || !glGetUniformBlockIndex || !glGetActiveUniformBlockiv
+            || !glGetActiveUniformBlockName || !glUniformBlockBinding
+            || !glDrawArraysInstanced || !glDrawElementsInstanced || !glFenceSync
+            || !glIsSync || !glDeleteSync || !glClientWaitSync || !glWaitSync
+            || !glGetInteger64v || !glGetSynciv || !glGetInteger64i_v
+            || !glGetBufferParameteri64v || !glGenSamplers || !glDeleteSamplers
+            || !glIsSampler || !glBindSampler || !glSamplerParameteri
+            || !glSamplerParameteriv || !glSamplerParameterf || !glSamplerParameterfv
+            || !glGetSamplerParameteriv || !glGetSamplerParameterfv
+            || !glVertexAttribDivisor || !glBindTransformFeedback
+            || !glDeleteTransformFeedbacks || !glGenTransformFeedbacks
+            || !glIsTransformFeedback || !glPauseTransformFeedback
+            || !glResumeTransformFeedback || !glGetProgramBinary || !glProgramBinary
+            || !glProgramParameteri || !glInvalidateFramebuffer
+            || !glInvalidateSubFramebuffer || !glTexStorage2D || !glTexStorage3D
+            || !glGetInternalformativ )
+    {
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+/* Function pointer definitions */GL_APICALL void (* GL_APIENTRY glReadBuffer)( GLenum mode );
+GL_APICALL void (* GL_APIENTRY glDrawRangeElements)( GLenum mode,
+        GLuint start,
+        GLuint end,
+        GLsizei count,
+        GLenum type,
+        const GLvoid* indices );
+GL_APICALL void (* GL_APIENTRY glTexImage3D)( GLenum target,
+        GLint level,
+        GLint internalformat,
+        GLsizei width,
+        GLsizei height,
+        GLsizei depth,
+        GLint border,
+        GLenum format,
+        GLenum type,
+        const GLvoid* pixels );
+GL_APICALL void (* GL_APIENTRY glTexSubImage3D)( GLenum target,
+        GLint level,
+        GLint xoffset,
+        GLint yoffset,
+        GLint zoffset,
+        GLsizei width,
+        GLsizei height,
+        GLsizei depth,
+        GLenum format,
+        GLenum type,
+        const GLvoid* pixels );
+GL_APICALL void (* GL_APIENTRY glCopyTexSubImage3D)( GLenum target,
+        GLint level,
+        GLint xoffset,
+        GLint yoffset,
+        GLint zoffset,
+        GLint x,
+        GLint y,
+        GLsizei width,
+        GLsizei height );
+GL_APICALL void (* GL_APIENTRY glCompressedTexImage3D)( GLenum target,
+        GLint level,
+        GLenum internalformat,
+        GLsizei width,
+        GLsizei height,
+        GLsizei depth,
+        GLint border,
+        GLsizei imageSize,
+        const GLvoid* data );
+GL_APICALL void (* GL_APIENTRY glCompressedTexSubImage3D)( GLenum target,
+        GLint level,
+        GLint xoffset,
+        GLint yoffset,
+        GLint zoffset,
+        GLsizei width,
+        GLsizei height,
+        GLsizei depth,
+        GLenum format,
+        GLsizei imageSize,
+        const GLvoid* data );
+GL_APICALL void (* GL_APIENTRY glGenQueries)( GLsizei n, GLuint* ids );
+GL_APICALL void (* GL_APIENTRY glDeleteQueries)( GLsizei n, const GLuint* ids );
+GL_APICALL GLboolean (* GL_APIENTRY glIsQuery)( GLuint id );
+GL_APICALL void (* GL_APIENTRY glBeginQuery)( GLenum target, GLuint id );
+GL_APICALL void (* GL_APIENTRY glEndQuery)( GLenum target );
+GL_APICALL void (* GL_APIENTRY glGetQueryiv)( GLenum target, GLenum pname, GLint* params );
+GL_APICALL void (* GL_APIENTRY glGetQueryObjectuiv)( GLuint id,
+        GLenum pname,
+        GLuint* params );
+GL_APICALL GLboolean (* GL_APIENTRY glUnmapBuffer)( GLenum target );
+GL_APICALL void (* GL_APIENTRY glGetBufferPointerv)( GLenum target,
+        GLenum pname,
+        GLvoid** params );
+GL_APICALL void (* GL_APIENTRY glDrawBuffers)( GLsizei n, const GLenum* bufs );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix2x3fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix3x2fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix2x4fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix4x2fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix3x4fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix4x3fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glBlitFramebuffer)( GLint srcX0,
+        GLint srcY0,
+        GLint srcX1,
+        GLint srcY1,
+        GLint dstX0,
+        GLint dstY0,
+        GLint dstX1,
+        GLint dstY1,
+        GLbitfield mask,
+        GLenum filter );
+GL_APICALL void (* GL_APIENTRY glRenderbufferStorageMultisample)( GLenum target,
+        GLsizei samples,
+        GLenum internalformat,
+        GLsizei width,
+        GLsizei height );
+GL_APICALL void (* GL_APIENTRY glFramebufferTextureLayer)( GLenum target,
+        GLenum attachment,
+        GLuint texture,
+        GLint level,
+        GLint layer );
+GL_APICALL GLvoid* (* GL_APIENTRY glMapBufferRange)( GLenum target,
+        GLintptr offset,
+        GLsizeiptr length,
+        GLbitfield access );
+GL_APICALL void (* GL_APIENTRY glFlushMappedBufferRange)( GLenum target,
+        GLintptr offset,
+        GLsizeiptr length );
+GL_APICALL void (* GL_APIENTRY glBindVertexArray)( GLuint array );
+GL_APICALL void (* GL_APIENTRY glDeleteVertexArrays)( GLsizei n, const GLuint* arrays );
+GL_APICALL void (* GL_APIENTRY glGenVertexArrays)( GLsizei n, GLuint* arrays );
+GL_APICALL GLboolean (* GL_APIENTRY glIsVertexArray)( GLuint array );
+GL_APICALL void (* GL_APIENTRY glGetIntegeri_v)( GLenum target,
+        GLuint index,
+        GLint* data );
+GL_APICALL void (* GL_APIENTRY glBeginTransformFeedback)( GLenum primitiveMode );
+GL_APICALL void (* GL_APIENTRY glEndTransformFeedback)( void );
+GL_APICALL void (* GL_APIENTRY glBindBufferRange)( GLenum target,
+        GLuint index,
+        GLuint buffer,
+        GLintptr offset,
+        GLsizeiptr size );
+GL_APICALL void (* GL_APIENTRY glBindBufferBase)( GLenum target,
+        GLuint index,
+        GLuint buffer );
+GL_APICALL void (* GL_APIENTRY glTransformFeedbackVaryings)( GLuint program,
+        GLsizei count,
+        const GLchar* const * varyings,
+        GLenum bufferMode );
+GL_APICALL void (* GL_APIENTRY glGetTransformFeedbackVarying)( GLuint program,
+        GLuint index,
+        GLsizei bufSize,
+        GLsizei* length,
+        GLsizei* size,
+        GLenum* type,
+        GLchar* name );
+GL_APICALL void (* GL_APIENTRY glVertexAttribIPointer)( GLuint index,
+        GLint size,
+        GLenum type,
+        GLsizei stride,
+        const GLvoid* pointer );
+GL_APICALL void (* GL_APIENTRY glGetVertexAttribIiv)( GLuint index,
+        GLenum pname,
+        GLint* params );
+GL_APICALL void (* GL_APIENTRY glGetVertexAttribIuiv)( GLuint index,
+        GLenum pname,
+        GLuint* params );
+GL_APICALL void (* GL_APIENTRY glVertexAttribI4i)( GLuint index,
+        GLint x,
+        GLint y,
+        GLint z,
+        GLint w );
+GL_APICALL void (* GL_APIENTRY glVertexAttribI4ui)( GLuint index,
+        GLuint x,
+        GLuint y,
+        GLuint z,
+        GLuint w );
+GL_APICALL void (* GL_APIENTRY glVertexAttribI4iv)( GLuint index, const GLint* v );
+GL_APICALL void (* GL_APIENTRY glVertexAttribI4uiv)( GLuint index, const GLuint* v );
+GL_APICALL void (* GL_APIENTRY glGetUniformuiv)( GLuint program,
+        GLint location,
+        GLuint* params );
+GL_APICALL GLint (* GL_APIENTRY glGetFragDataLocation)( GLuint program,
+        const GLchar *name );
+GL_APICALL void (* GL_APIENTRY glUniform1ui)( GLint location, GLuint v0 );
+GL_APICALL void (* GL_APIENTRY glUniform2ui)( GLint location, GLuint v0, GLuint v1 );
+GL_APICALL void (* GL_APIENTRY glUniform3ui)( GLint location,
+        GLuint v0,
+        GLuint v1,
+        GLuint v2 );
+GL_APICALL void (* GL_APIENTRY glUniform4ui)( GLint location,
+        GLuint v0,
+        GLuint v1,
+        GLuint v2,
+        GLuint v3 );
+GL_APICALL void (* GL_APIENTRY glUniform1uiv)( GLint location,
+        GLsizei count,
+        const GLuint* value );
+GL_APICALL void (* GL_APIENTRY glUniform2uiv)( GLint location,
+        GLsizei count,
+        const GLuint* value );
+GL_APICALL void (* GL_APIENTRY glUniform3uiv)( GLint location,
+        GLsizei count,
+        const GLuint* value );
+GL_APICALL void (* GL_APIENTRY glUniform4uiv)( GLint location,
+        GLsizei count,
+        const GLuint* value );
+GL_APICALL void (* GL_APIENTRY glClearBufferiv)( GLenum buffer,
+        GLint drawbuffer,
+        const GLint* value );
+GL_APICALL void (* GL_APIENTRY glClearBufferuiv)( GLenum buffer,
+        GLint drawbuffer,
+        const GLuint* value );
+GL_APICALL void (* GL_APIENTRY glClearBufferfv)( GLenum buffer,
+        GLint drawbuffer,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glClearBufferfi)( GLenum buffer,
+        GLint drawbuffer,
+        GLfloat depth,
+        GLint stencil );
+GL_APICALL const GLubyte* (* GL_APIENTRY glGetStringi)( GLenum name, GLuint index );
+GL_APICALL void (* GL_APIENTRY glCopyBufferSubData)( GLenum readTarget,
+        GLenum writeTarget,
+        GLintptr readOffset,
+        GLintptr writeOffset,
+        GLsizeiptr size );
+GL_APICALL void (* GL_APIENTRY glGetUniformIndices)( GLuint program,
+        GLsizei uniformCount,
+        const GLchar* const * uniformNames,
+        GLuint* uniformIndices );
+GL_APICALL void (* GL_APIENTRY glGetActiveUniformsiv)( GLuint program,
+        GLsizei uniformCount,
+        const GLuint* uniformIndices,
+        GLenum pname,
+        GLint* params );
+GL_APICALL GLuint (* GL_APIENTRY glGetUniformBlockIndex)( GLuint program,
+        const GLchar* uniformBlockName );
+GL_APICALL void (* GL_APIENTRY glGetActiveUniformBlockiv)( GLuint program,
+        GLuint uniformBlockIndex,
+        GLenum pname,
+        GLint* params );
+GL_APICALL void (* GL_APIENTRY glGetActiveUniformBlockName)( GLuint program,
+        GLuint uniformBlockIndex,
+        GLsizei bufSize,
+        GLsizei* length,
+        GLchar* uniformBlockName );
+GL_APICALL void (* GL_APIENTRY glUniformBlockBinding)( GLuint program,
+        GLuint uniformBlockIndex,
+        GLuint uniformBlockBinding );
+GL_APICALL void (* GL_APIENTRY glDrawArraysInstanced)( GLenum mode,
+        GLint first,
+        GLsizei count,
+        GLsizei instanceCount );
+GL_APICALL void (* GL_APIENTRY glDrawElementsInstanced)( GLenum mode,
+        GLsizei count,
+        GLenum type,
+        const GLvoid* indices,
+        GLsizei instanceCount );
+GL_APICALL GLsync (* GL_APIENTRY glFenceSync)( GLenum condition, GLbitfield flags );
+GL_APICALL GLboolean (* GL_APIENTRY glIsSync)( GLsync sync );
+GL_APICALL void (* GL_APIENTRY glDeleteSync)( GLsync sync );
+GL_APICALL GLenum (* GL_APIENTRY glClientWaitSync)( GLsync sync,
+        GLbitfield flags,
+        GLuint64 timeout );
+GL_APICALL void (* GL_APIENTRY glWaitSync)( GLsync sync,
+        GLbitfield flags,
+        GLuint64 timeout );
+GL_APICALL void (* GL_APIENTRY glGetInteger64v)( GLenum pname, GLint64* params );
+GL_APICALL void (* GL_APIENTRY glGetSynciv)( GLsync sync,
+        GLenum pname,
+        GLsizei bufSize,
+        GLsizei* length,
+        GLint* values );
+GL_APICALL void (* GL_APIENTRY glGetInteger64i_v)( GLenum target,
+        GLuint index,
+        GLint64* data );
+GL_APICALL void (* GL_APIENTRY glGetBufferParameteri64v)( GLenum target,
+        GLenum pname,
+        GLint64* params );
+GL_APICALL void (* GL_APIENTRY glGenSamplers)( GLsizei count, GLuint* samplers );
+GL_APICALL void (* GL_APIENTRY glDeleteSamplers)( GLsizei count, const GLuint* samplers );
+GL_APICALL GLboolean (* GL_APIENTRY glIsSampler)( GLuint sampler );
+GL_APICALL void (* GL_APIENTRY glBindSampler)( GLuint unit, GLuint sampler );
+GL_APICALL void (* GL_APIENTRY glSamplerParameteri)( GLuint sampler,
+        GLenum pname,
+        GLint param );
+GL_APICALL void (* GL_APIENTRY glSamplerParameteriv)( GLuint sampler,
+        GLenum pname,
+        const GLint* param );
+GL_APICALL void (* GL_APIENTRY glSamplerParameterf)( GLuint sampler,
+        GLenum pname,
+        GLfloat param );
+GL_APICALL void (* GL_APIENTRY glSamplerParameterfv)( GLuint sampler,
+        GLenum pname,
+        const GLfloat* param );
+GL_APICALL void (* GL_APIENTRY glGetSamplerParameteriv)( GLuint sampler,
+        GLenum pname,
+        GLint* params );
+GL_APICALL void (* GL_APIENTRY glGetSamplerParameterfv)( GLuint sampler,
+        GLenum pname,
+        GLfloat* params );
+GL_APICALL void (* GL_APIENTRY glVertexAttribDivisor)( GLuint index, GLuint divisor );
+GL_APICALL void (* GL_APIENTRY glBindTransformFeedback)( GLenum target, GLuint id );
+GL_APICALL void (* GL_APIENTRY glDeleteTransformFeedbacks)( GLsizei n, const GLuint* ids );
+GL_APICALL void (* GL_APIENTRY glGenTransformFeedbacks)( GLsizei n, GLuint* ids );
+GL_APICALL GLboolean (* GL_APIENTRY glIsTransformFeedback)( GLuint id );
+GL_APICALL void (* GL_APIENTRY glPauseTransformFeedback)( void );
+GL_APICALL void (* GL_APIENTRY glResumeTransformFeedback)( void );
+GL_APICALL void (* GL_APIENTRY glGetProgramBinary)( GLuint program,
+        GLsizei bufSize,
+        GLsizei* length,
+        GLenum* binaryFormat,
+        GLvoid* binary );
+GL_APICALL void (* GL_APIENTRY glProgramBinary)( GLuint program,
+        GLenum binaryFormat,
+        const GLvoid* binary,
+        GLsizei length );
+GL_APICALL void (* GL_APIENTRY glProgramParameteri)( GLuint program,
+        GLenum pname,
+        GLint value );
+GL_APICALL void (* GL_APIENTRY glInvalidateFramebuffer)( GLenum target,
+        GLsizei numAttachments,
+        const GLenum* attachments );
+GL_APICALL void (* GL_APIENTRY glInvalidateSubFramebuffer)( GLenum target,
+        GLsizei numAttachments,
+        const GLenum* attachments,
+        GLint x,
+        GLint y,
+        GLsizei width,
+        GLsizei height );
+GL_APICALL void (* GL_APIENTRY glTexStorage2D)( GLenum target,
+        GLsizei levels,
+        GLenum internalformat,
+        GLsizei width,
+        GLsizei height );
+GL_APICALL void (* GL_APIENTRY glTexStorage3D)( GLenum target,
+        GLsizei levels,
+        GLenum internalformat,
+        GLsizei width,
+        GLsizei height,
+        GLsizei depth );
+GL_APICALL void (* GL_APIENTRY glGetInternalformativ)( GLenum target,
+        GLenum internalformat,
+        GLenum pname,
+        GLsizei bufSize,
+        GLint* params );

MoreTeapots/app/src/main/jni/ndk_helper/gl3stub.h

@@ -0,0 +1,663 @@
+#ifndef __gl3_h_
+#define __gl3_h_
+
+/*
+ * stub gl3.h for dynamic loading, based on:
+ * gl3.h last updated on $Date: 2013-02-12 14:37:24 -0800 (Tue, 12 Feb 2013) $
+ *
+ * Changes:
+ * - Added #include <GLES2/gl2.h>
+ * - Removed duplicate OpenGL ES 2.0 declarations
+ * - Converted OpenGL ES 3.0 function prototypes to function pointer
+ *   declarations
+ * - Added gl3stubInit() declaration
+ */
+
+#include <GLES2/gl2.h>
+#include <android/api-level.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ ** Copyright (c) 2007-2013 The Khronos Group Inc.
+ **
+ ** Permission is hereby granted, free of charge, to any person obtaining a
+ ** copy of this software and/or associated documentation files (the
+ ** "Materials"), to deal in the Materials without restriction, including
+ ** without limitation the rights to use, copy, modify, merge, publish,
+ ** distribute, sublicense, and/or sell copies of the Materials, and to
+ ** permit persons to whom the Materials are 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 Materials.
+ **
+ ** THE MATERIALS ARE 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
+ ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ */
+
+/*
+ * This files is for apps that want to use ES3 if present,
+ * but continue to work on pre-API-18 devices. They can't just link to -lGLESv3
+ *since
+ * that library doesn't exist on pre-API-18 devices.
+ * The function dynamically check if OpenGLES3.0 APIs are present and fill in if
+ *there are.
+ * Also the header defines some extra variables for OpenGLES3.0.
+ *
+ */
+
+/* Call this function before calling any OpenGL ES 3.0 functions. It will
+ * return GL_TRUE if the OpenGL ES 3.0 was successfully initialized, GL_FALSE
+ * otherwise. */
+GLboolean gl3stubInit();
+
+/*-------------------------------------------------------------------------
+ * Data type definitions
+ *-----------------------------------------------------------------------*/
+
+/* OpenGL ES 3.0 */
+
+typedef unsigned short GLhalf;
+#if __ANDROID_API__ <= 19
+typedef khronos_int64_t GLint64;
+typedef khronos_uint64_t GLuint64;
+typedef struct __GLsync* GLsync;
+#endif
+
+/*-------------------------------------------------------------------------
+ * Token definitions
+ *-----------------------------------------------------------------------*/
+
+/* OpenGL ES core versions */
+#define GL_ES_VERSION_3_0 1
+
+/* OpenGL ES 3.0 */
+
+#define GL_READ_BUFFER 0x0C02
+#define GL_UNPACK_ROW_LENGTH 0x0CF2
+#define GL_UNPACK_SKIP_ROWS 0x0CF3
+#define GL_UNPACK_SKIP_PIXELS 0x0CF4
+#define GL_PACK_ROW_LENGTH 0x0D02
+#define GL_PACK_SKIP_ROWS 0x0D03
+#define GL_PACK_SKIP_PIXELS 0x0D04
+#define GL_COLOR 0x1800
+#define GL_DEPTH 0x1801
+#define GL_STENCIL 0x1802
+#define GL_RED 0x1903
+#define GL_RGB8 0x8051
+#define GL_RGBA8 0x8058
+#define GL_RGB10_A2 0x8059
+#define GL_TEXTURE_BINDING_3D 0x806A
+#define GL_UNPACK_SKIP_IMAGES 0x806D
+#define GL_UNPACK_IMAGE_HEIGHT 0x806E
+#define GL_TEXTURE_3D 0x806F
+#define GL_TEXTURE_WRAP_R 0x8072
+#define GL_MAX_3D_TEXTURE_SIZE 0x8073
+#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
+#define GL_MAX_ELEMENTS_VERTICES 0x80E8
+#define GL_MAX_ELEMENTS_INDICES 0x80E9
+#define GL_TEXTURE_MIN_LOD 0x813A
+#define GL_TEXTURE_MAX_LOD 0x813B
+#define GL_TEXTURE_BASE_LEVEL 0x813C
+#define GL_TEXTURE_MAX_LEVEL 0x813D
+#define GL_MIN 0x8007
+#define GL_MAX 0x8008
+#define GL_DEPTH_COMPONENT24 0x81A6
+#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
+#define GL_TEXTURE_COMPARE_MODE 0x884C
+#define GL_TEXTURE_COMPARE_FUNC 0x884D
+#define GL_CURRENT_QUERY 0x8865
+#define GL_QUERY_RESULT 0x8866
+#define GL_QUERY_RESULT_AVAILABLE 0x8867
+#define GL_BUFFER_MAPPED 0x88BC
+#define GL_BUFFER_MAP_POINTER 0x88BD
+#define GL_STREAM_READ 0x88E1
+#define GL_STREAM_COPY 0x88E2
+#define GL_STATIC_READ 0x88E5
+#define GL_STATIC_COPY 0x88E6
+#define GL_DYNAMIC_READ 0x88E9
+#define GL_DYNAMIC_COPY 0x88EA
+#define GL_MAX_DRAW_BUFFERS 0x8824
+#define GL_DRAW_BUFFER0 0x8825
+#define GL_DRAW_BUFFER1 0x8826
+#define GL_DRAW_BUFFER2 0x8827
+#define GL_DRAW_BUFFER3 0x8828
+#define GL_DRAW_BUFFER4 0x8829
+#define GL_DRAW_BUFFER5 0x882A
+#define GL_DRAW_BUFFER6 0x882B
+#define GL_DRAW_BUFFER7 0x882C
+#define GL_DRAW_BUFFER8 0x882D
+#define GL_DRAW_BUFFER9 0x882E
+#define GL_DRAW_BUFFER10 0x882F
+#define GL_DRAW_BUFFER11 0x8830
+#define GL_DRAW_BUFFER12 0x8831
+#define GL_DRAW_BUFFER13 0x8832
+#define GL_DRAW_BUFFER14 0x8833
+#define GL_DRAW_BUFFER15 0x8834
+#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
+#define GL_SAMPLER_3D 0x8B5F
+#define GL_SAMPLER_2D_SHADOW 0x8B62
+#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
+#define GL_PIXEL_PACK_BUFFER 0x88EB
+#define GL_PIXEL_UNPACK_BUFFER 0x88EC
+#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
+#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
+#define GL_FLOAT_MAT2x3 0x8B65
+#define GL_FLOAT_MAT2x4 0x8B66
+#define GL_FLOAT_MAT3x2 0x8B67
+#define GL_FLOAT_MAT3x4 0x8B68
+#define GL_FLOAT_MAT4x2 0x8B69
+#define GL_FLOAT_MAT4x3 0x8B6A
+#define GL_SRGB 0x8C40
+#define GL_SRGB8 0x8C41
+#define GL_SRGB8_ALPHA8 0x8C43
+#define GL_COMPARE_REF_TO_TEXTURE 0x884E
+#define GL_MAJOR_VERSION 0x821B
+#define GL_MINOR_VERSION 0x821C
+#define GL_NUM_EXTENSIONS 0x821D
+#define GL_RGBA32F 0x8814
+#define GL_RGB32F 0x8815
+#define GL_RGBA16F 0x881A
+#define GL_RGB16F 0x881B
+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD
+#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF
+#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904
+#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905
+#define GL_MAX_VARYING_COMPONENTS 0x8B4B
+#define GL_TEXTURE_2D_ARRAY 0x8C1A
+#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D
+#define GL_R11F_G11F_B10F 0x8C3A
+#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B
+#define GL_RGB9_E5 0x8C3D
+#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E
+#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
+#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
+#define GL_RASTERIZER_DISCARD 0x8C89
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
+#define GL_INTERLEAVED_ATTRIBS 0x8C8C
+#define GL_SEPARATE_ATTRIBS 0x8C8D
+#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
+#define GL_RGBA32UI 0x8D70
+#define GL_RGB32UI 0x8D71
+#define GL_RGBA16UI 0x8D76
+#define GL_RGB16UI 0x8D77
+#define GL_RGBA8UI 0x8D7C
+#define GL_RGB8UI 0x8D7D
+#define GL_RGBA32I 0x8D82
+#define GL_RGB32I 0x8D83
+#define GL_RGBA16I 0x8D88
+#define GL_RGB16I 0x8D89
+#define GL_RGBA8I 0x8D8E
+#define GL_RGB8I 0x8D8F
+#define GL_RED_INTEGER 0x8D94
+#define GL_RGB_INTEGER 0x8D98
+#define GL_RGBA_INTEGER 0x8D99
+#define GL_SAMPLER_2D_ARRAY 0x8DC1
+#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4
+#define GL_SAMPLER_CUBE_SHADOW 0x8DC5
+#define GL_UNSIGNED_INT_VEC2 0x8DC6
+#define GL_UNSIGNED_INT_VEC3 0x8DC7
+#define GL_UNSIGNED_INT_VEC4 0x8DC8
+#define GL_INT_SAMPLER_2D 0x8DCA
+#define GL_INT_SAMPLER_3D 0x8DCB
+#define GL_INT_SAMPLER_CUBE 0x8DCC
+#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF
+#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2
+#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3
+#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4
+#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7
+#define GL_BUFFER_ACCESS_FLAGS 0x911F
+#define GL_BUFFER_MAP_LENGTH 0x9120
+#define GL_BUFFER_MAP_OFFSET 0x9121
+#define GL_DEPTH_COMPONENT32F 0x8CAC
+#define GL_DEPTH32F_STENCIL8 0x8CAD
+#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
+#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
+#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
+#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
+#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
+#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
+#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
+#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
+#define GL_FRAMEBUFFER_DEFAULT 0x8218
+#define GL_FRAMEBUFFER_UNDEFINED 0x8219
+#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
+#define GL_DEPTH_STENCIL 0x84F9
+#define GL_UNSIGNED_INT_24_8 0x84FA
+#define GL_DEPTH24_STENCIL8 0x88F0
+#define GL_UNSIGNED_NORMALIZED 0x8C17
+#define GL_DRAW_FRAMEBUFFER_BINDING GL_FRAMEBUFFER_BINDING
+#define GL_READ_FRAMEBUFFER 0x8CA8
+#define GL_DRAW_FRAMEBUFFER 0x8CA9
+#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA
+#define GL_RENDERBUFFER_SAMPLES 0x8CAB
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
+#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
+#define GL_COLOR_ATTACHMENT1 0x8CE1
+#define GL_COLOR_ATTACHMENT2 0x8CE2
+#define GL_COLOR_ATTACHMENT3 0x8CE3
+#define GL_COLOR_ATTACHMENT4 0x8CE4
+#define GL_COLOR_ATTACHMENT5 0x8CE5
+#define GL_COLOR_ATTACHMENT6 0x8CE6
+#define GL_COLOR_ATTACHMENT7 0x8CE7
+#define GL_COLOR_ATTACHMENT8 0x8CE8
+#define GL_COLOR_ATTACHMENT9 0x8CE9
+#define GL_COLOR_ATTACHMENT10 0x8CEA
+#define GL_COLOR_ATTACHMENT11 0x8CEB
+#define GL_COLOR_ATTACHMENT12 0x8CEC
+#define GL_COLOR_ATTACHMENT13 0x8CED
+#define GL_COLOR_ATTACHMENT14 0x8CEE
+#define GL_COLOR_ATTACHMENT15 0x8CEF
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
+#define GL_MAX_SAMPLES 0x8D57
+#define GL_HALF_FLOAT 0x140B
+#define GL_MAP_READ_BIT 0x0001
+#define GL_MAP_WRITE_BIT 0x0002
+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
+#define GL_RG 0x8227
+#define GL_RG_INTEGER 0x8228
+#define GL_R8 0x8229
+#define GL_RG8 0x822B
+#define GL_R16F 0x822D
+#define GL_R32F 0x822E
+#define GL_RG16F 0x822F
+#define GL_RG32F 0x8230
+#define GL_R8I 0x8231
+#define GL_R8UI 0x8232
+#define GL_R16I 0x8233
+#define GL_R16UI 0x8234
+#define GL_R32I 0x8235
+#define GL_R32UI 0x8236
+#define GL_RG8I 0x8237
+#define GL_RG8UI 0x8238
+#define GL_RG16I 0x8239
+#define GL_RG16UI 0x823A
+#define GL_RG32I 0x823B
+#define GL_RG32UI 0x823C
+#define GL_VERTEX_ARRAY_BINDING 0x85B5
+#define GL_R8_SNORM 0x8F94
+#define GL_RG8_SNORM 0x8F95
+#define GL_RGB8_SNORM 0x8F96
+#define GL_RGBA8_SNORM 0x8F97
+#define GL_SIGNED_NORMALIZED 0x8F9C
+#define GL_PRIMITIVE_RESTART_FIXED_INDEX 0x8D69
+#define GL_COPY_READ_BUFFER 0x8F36
+#define GL_COPY_WRITE_BUFFER 0x8F37
+#define GL_COPY_READ_BUFFER_BINDING GL_COPY_READ_BUFFER
+#define GL_COPY_WRITE_BUFFER_BINDING GL_COPY_WRITE_BUFFER
+#define GL_UNIFORM_BUFFER 0x8A11
+#define GL_UNIFORM_BUFFER_BINDING 0x8A28
+#define GL_UNIFORM_BUFFER_START 0x8A29
+#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
+#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
+#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
+#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
+#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
+#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
+#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
+#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
+#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
+#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
+#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
+#define GL_UNIFORM_TYPE 0x8A37
+#define GL_UNIFORM_SIZE 0x8A38
+#define GL_UNIFORM_NAME_LENGTH 0x8A39
+#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
+#define GL_UNIFORM_OFFSET 0x8A3B
+#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
+#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
+#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
+#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
+#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
+#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
+#define GL_INVALID_INDEX 0xFFFFFFFFu
+#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
+#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
+#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
+#define GL_OBJECT_TYPE 0x9112
+#define GL_SYNC_CONDITION 0x9113
+#define GL_SYNC_STATUS 0x9114
+#define GL_SYNC_FLAGS 0x9115
+#define GL_SYNC_FENCE 0x9116
+#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
+#define GL_UNSIGNALED 0x9118
+#define GL_SIGNALED 0x9119
+#define GL_ALREADY_SIGNALED 0x911A
+#define GL_TIMEOUT_EXPIRED 0x911B
+#define GL_CONDITION_SATISFIED 0x911C
+#define GL_WAIT_FAILED 0x911D
+#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
+#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFFull
+#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE
+#define GL_ANY_SAMPLES_PASSED 0x8C2F
+#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE 0x8D6A
+#define GL_SAMPLER_BINDING 0x8919
+#define GL_RGB10_A2UI 0x906F
+#define GL_TEXTURE_SWIZZLE_R 0x8E42
+#define GL_TEXTURE_SWIZZLE_G 0x8E43
+#define GL_TEXTURE_SWIZZLE_B 0x8E44
+#define GL_TEXTURE_SWIZZLE_A 0x8E45
+#define GL_GREEN 0x1904
+#define GL_BLUE 0x1905
+#define GL_INT_2_10_10_10_REV 0x8D9F
+#define GL_TRANSFORM_FEEDBACK 0x8E22
+#define GL_TRANSFORM_FEEDBACK_PAUSED 0x8E23
+#define GL_TRANSFORM_FEEDBACK_ACTIVE 0x8E24
+#define GL_TRANSFORM_FEEDBACK_BINDING 0x8E25
+#define GL_PROGRAM_BINARY_RETRIEVABLE_HINT 0x8257
+#define GL_PROGRAM_BINARY_LENGTH 0x8741
+#define GL_NUM_PROGRAM_BINARY_FORMATS 0x87FE
+#define GL_PROGRAM_BINARY_FORMATS 0x87FF
+#define GL_COMPRESSED_R11_EAC 0x9270
+#define GL_COMPRESSED_SIGNED_R11_EAC 0x9271
+#define GL_COMPRESSED_RG11_EAC 0x9272
+#define GL_COMPRESSED_SIGNED_RG11_EAC 0x9273
+#define GL_COMPRESSED_RGB8_ETC2 0x9274
+#define GL_COMPRESSED_SRGB8_ETC2 0x9275
+#define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276
+#define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277
+#define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278
+#define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279
+#define GL_TEXTURE_IMMUTABLE_FORMAT 0x912F
+#define GL_MAX_ELEMENT_INDEX 0x8D6B
+#define GL_NUM_SAMPLE_COUNTS 0x9380
+#define GL_TEXTURE_IMMUTABLE_LEVELS 0x82DF
+
+/*-------------------------------------------------------------------------
+ * Entrypoint definitions
+ *-----------------------------------------------------------------------*/
+
+/* OpenGL ES 3.0 */
+
+extern GL_APICALL void (*GL_APIENTRY glReadBuffer)(GLenum mode);
+extern GL_APICALL void (*GL_APIENTRY glDrawRangeElements)(
+    GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
+    const GLvoid* indices);
+extern GL_APICALL void (*GL_APIENTRY glTexImage3D)(
+    GLenum target, GLint level, GLint internalformat, GLsizei width,
+    GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type,
+    const GLvoid* pixels);
+extern GL_APICALL void (*GL_APIENTRY glTexSubImage3D)(
+    GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
+    GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type,
+    const GLvoid* pixels);
+extern GL_APICALL void (*GL_APIENTRY glCopyTexSubImage3D)(
+    GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
+    GLint x, GLint y, GLsizei width, GLsizei height);
+extern GL_APICALL void (*GL_APIENTRY glCompressedTexImage3D)(
+    GLenum target, GLint level, GLenum internalformat, GLsizei width,
+    GLsizei height, GLsizei depth, GLint border, GLsizei imageSize,
+    const GLvoid* data);
+extern GL_APICALL void (*GL_APIENTRY glCompressedTexSubImage3D)(
+    GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
+    GLsizei width, GLsizei height, GLsizei depth, GLenum format,
+    GLsizei imageSize, const GLvoid* data);
+extern GL_APICALL void (*GL_APIENTRY glGenQueries)(GLsizei n, GLuint* ids);
+extern GL_APICALL void (*GL_APIENTRY glDeleteQueries)(GLsizei n,
+                                                      const GLuint* ids);
+extern GL_APICALL GLboolean (*GL_APIENTRY glIsQuery)(GLuint id);
+extern GL_APICALL void (*GL_APIENTRY glBeginQuery)(GLenum target, GLuint id);
+extern GL_APICALL void (*GL_APIENTRY glEndQuery)(GLenum target);
+extern GL_APICALL void (*GL_APIENTRY glGetQueryiv)(GLenum target, GLenum pname,
+                                                   GLint* params);
+extern GL_APICALL void (*GL_APIENTRY glGetQueryObjectuiv)(GLuint id,
+                                                          GLenum pname,
+                                                          GLuint* params);
+extern GL_APICALL GLboolean (*GL_APIENTRY glUnmapBuffer)(GLenum target);
+extern GL_APICALL void (*GL_APIENTRY glGetBufferPointerv)(GLenum target,
+                                                          GLenum pname,
+                                                          GLvoid** params);
+extern GL_APICALL void (*GL_APIENTRY glDrawBuffers)(GLsizei n,
+                                                    const GLenum* bufs);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix2x3fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix3x2fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix2x4fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix4x2fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix3x4fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix4x3fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glBlitFramebuffer)(
+    GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0,
+    GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+extern GL_APICALL void (*GL_APIENTRY glRenderbufferStorageMultisample)(
+    GLenum target, GLsizei samples, GLenum internalformat, GLsizei width,
+    GLsizei height);
+extern GL_APICALL void (*GL_APIENTRY glFramebufferTextureLayer)(
+    GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+extern GL_APICALL GLvoid* (*GL_APIENTRY glMapBufferRange)(GLenum target,
+                                                          GLintptr offset,
+                                                          GLsizeiptr length,
+                                                          GLbitfield access);
+extern GL_APICALL void (*GL_APIENTRY glFlushMappedBufferRange)(
+    GLenum target, GLintptr offset, GLsizeiptr length);
+extern GL_APICALL void (*GL_APIENTRY glBindVertexArray)(GLuint array);
+extern GL_APICALL void (*GL_APIENTRY
+                            glDeleteVertexArrays)(GLsizei n,
+                                                  const GLuint* arrays);
+extern GL_APICALL void (*GL_APIENTRY glGenVertexArrays)(GLsizei n,
+                                                        GLuint* arrays);
+extern GL_APICALL GLboolean (*GL_APIENTRY glIsVertexArray)(GLuint array);
+extern GL_APICALL void (*GL_APIENTRY glGetIntegeri_v)(GLenum target,
+                                                      GLuint index,
+                                                      GLint* data);
+extern GL_APICALL void (*GL_APIENTRY
+                            glBeginTransformFeedback)(GLenum primitiveMode);
+extern GL_APICALL void (*GL_APIENTRY glEndTransformFeedback)(void);
+extern GL_APICALL void (*GL_APIENTRY
+                            glBindBufferRange)(GLenum target, GLuint index,
+                                               GLuint buffer, GLintptr offset,
+                                               GLsizeiptr size);
+extern GL_APICALL void (*GL_APIENTRY glBindBufferBase)(GLenum target,
+                                                       GLuint index,
+                                                       GLuint buffer);
+extern GL_APICALL void (*GL_APIENTRY glTransformFeedbackVaryings)(
+    GLuint program, GLsizei count, const GLchar* const* varyings,
+    GLenum bufferMode);
+extern GL_APICALL void (*GL_APIENTRY glGetTransformFeedbackVarying)(
+    GLuint program, GLuint index, GLsizei bufSize, GLsizei* length,
+    GLsizei* size, GLenum* type, GLchar* name);
+extern GL_APICALL void (*GL_APIENTRY
+                            glVertexAttribIPointer)(GLuint index, GLint size,
+                                                    GLenum type, GLsizei stride,
+                                                    const GLvoid* pointer);
+extern GL_APICALL void (*GL_APIENTRY glGetVertexAttribIiv)(GLuint index,
+                                                           GLenum pname,
+                                                           GLint* params);
+extern GL_APICALL void (*GL_APIENTRY glGetVertexAttribIuiv)(GLuint index,
+                                                            GLenum pname,
+                                                            GLuint* params);
+extern GL_APICALL void (*GL_APIENTRY glVertexAttribI4i)(GLuint index, GLint x,
+                                                        GLint y, GLint z,
+                                                        GLint w);
+extern GL_APICALL void (*GL_APIENTRY glVertexAttribI4ui)(GLuint index, GLuint x,
+                                                         GLuint y, GLuint z,
+                                                         GLuint w);
+extern GL_APICALL void (*GL_APIENTRY glVertexAttribI4iv)(GLuint index,
+                                                         const GLint* v);
+extern GL_APICALL void (*GL_APIENTRY glVertexAttribI4uiv)(GLuint index,
+                                                          const GLuint* v);
+extern GL_APICALL void (*GL_APIENTRY glGetUniformuiv)(GLuint program,
+                                                      GLint location,
+                                                      GLuint* params);
+extern GL_APICALL GLint (*GL_APIENTRY
+                             glGetFragDataLocation)(GLuint program,
+                                                    const GLchar* name);
+extern GL_APICALL void (*GL_APIENTRY glUniform1ui)(GLint location, GLuint v0);
+extern GL_APICALL void (*GL_APIENTRY glUniform2ui)(GLint location, GLuint v0,
+                                                   GLuint v1);
+extern GL_APICALL void (*GL_APIENTRY glUniform3ui)(GLint location, GLuint v0,
+                                                   GLuint v1, GLuint v2);
+extern GL_APICALL void (*GL_APIENTRY glUniform4ui)(GLint location, GLuint v0,
+                                                   GLuint v1, GLuint v2,
+                                                   GLuint v3);
+extern GL_APICALL void (*GL_APIENTRY glUniform1uiv)(GLint location,
+                                                    GLsizei count,
+                                                    const GLuint* value);
+extern GL_APICALL void (*GL_APIENTRY glUniform2uiv)(GLint location,
+                                                    GLsizei count,
+                                                    const GLuint* value);
+extern GL_APICALL void (*GL_APIENTRY glUniform3uiv)(GLint location,
+                                                    GLsizei count,
+                                                    const GLuint* value);
+extern GL_APICALL void (*GL_APIENTRY glUniform4uiv)(GLint location,
+                                                    GLsizei count,
+                                                    const GLuint* value);
+extern GL_APICALL void (*GL_APIENTRY glClearBufferiv)(GLenum buffer,
+                                                      GLint drawbuffer,
+                                                      const GLint* value);
+extern GL_APICALL void (*GL_APIENTRY glClearBufferuiv)(GLenum buffer,
+                                                       GLint drawbuffer,
+                                                       const GLuint* value);
+extern GL_APICALL void (*GL_APIENTRY glClearBufferfv)(GLenum buffer,
+                                                      GLint drawbuffer,
+                                                      const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY
+                            glClearBufferfi)(GLenum buffer, GLint drawbuffer,
+                                             GLfloat depth, GLint stencil);
+extern GL_APICALL const GLubyte* (*GL_APIENTRY glGetStringi)(GLenum name,
+                                                             GLuint index);
+extern GL_APICALL void (*GL_APIENTRY glCopyBufferSubData)(GLenum readTarget,
+                                                          GLenum writeTarget,
+                                                          GLintptr readOffset,
+                                                          GLintptr writeOffset,
+                                                          GLsizeiptr size);
+extern GL_APICALL void (*GL_APIENTRY glGetUniformIndices)(
+    GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames,
+    GLuint* uniformIndices);
+extern GL_APICALL void (*GL_APIENTRY glGetActiveUniformsiv)(
+    GLuint program, GLsizei uniformCount, const GLuint* uniformIndices,
+    GLenum pname, GLint* params);
+extern GL_APICALL GLuint (*GL_APIENTRY glGetUniformBlockIndex)(
+    GLuint program, const GLchar* uniformBlockName);
+extern GL_APICALL void (*GL_APIENTRY glGetActiveUniformBlockiv)(
+    GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params);
+extern GL_APICALL void (*GL_APIENTRY glGetActiveUniformBlockName)(
+    GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length,
+    GLchar* uniformBlockName);
+extern GL_APICALL void (*GL_APIENTRY glUniformBlockBinding)(
+    GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+extern GL_APICALL void (*GL_APIENTRY glDrawArraysInstanced)(
+    GLenum mode, GLint first, GLsizei count, GLsizei instanceCount);
+extern GL_APICALL void (*GL_APIENTRY glDrawElementsInstanced)(
+    GLenum mode, GLsizei count, GLenum type, const GLvoid* indices,
+    GLsizei instanceCount);
+extern GL_APICALL GLsync (*GL_APIENTRY glFenceSync)(GLenum condition,
+                                                    GLbitfield flags);
+extern GL_APICALL GLboolean (*GL_APIENTRY glIsSync)(GLsync sync);
+extern GL_APICALL void (*GL_APIENTRY glDeleteSync)(GLsync sync);
+extern GL_APICALL GLenum (*GL_APIENTRY glClientWaitSync)(GLsync sync,
+                                                         GLbitfield flags,
+                                                         GLuint64 timeout);
+extern GL_APICALL void (*GL_APIENTRY glWaitSync)(GLsync sync, GLbitfield flags,
+                                                 GLuint64 timeout);
+extern GL_APICALL void (*GL_APIENTRY glGetInteger64v)(GLenum pname,
+                                                      GLint64* params);
+extern GL_APICALL void (*GL_APIENTRY glGetSynciv)(GLsync sync, GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  GLint* values);
+extern GL_APICALL void (*GL_APIENTRY glGetInteger64i_v)(GLenum target,
+                                                        GLuint index,
+                                                        GLint64* data);
+extern GL_APICALL void (*GL_APIENTRY glGetBufferParameteri64v)(GLenum target,
+                                                               GLenum pname,
+                                                               GLint64* params);
+extern GL_APICALL void (*GL_APIENTRY glGenSamplers)(GLsizei count,
+                                                    GLuint* samplers);
+extern GL_APICALL void (*GL_APIENTRY glDeleteSamplers)(GLsizei count,
+                                                       const GLuint* samplers);
+extern GL_APICALL GLboolean (*GL_APIENTRY glIsSampler)(GLuint sampler);
+extern GL_APICALL void (*GL_APIENTRY glBindSampler)(GLuint unit,
+                                                    GLuint sampler);
+extern GL_APICALL void (*GL_APIENTRY glSamplerParameteri)(GLuint sampler,
+                                                          GLenum pname,
+                                                          GLint param);
+extern GL_APICALL void (*GL_APIENTRY glSamplerParameteriv)(GLuint sampler,
+                                                           GLenum pname,
+                                                           const GLint* param);
+extern GL_APICALL void (*GL_APIENTRY glSamplerParameterf)(GLuint sampler,
+                                                          GLenum pname,
+                                                          GLfloat param);
+extern GL_APICALL void (*GL_APIENTRY
+                            glSamplerParameterfv)(GLuint sampler, GLenum pname,
+                                                  const GLfloat* param);
+extern GL_APICALL void (*GL_APIENTRY glGetSamplerParameteriv)(GLuint sampler,
+                                                              GLenum pname,
+                                                              GLint* params);
+extern GL_APICALL void (*GL_APIENTRY glGetSamplerParameterfv)(GLuint sampler,
+                                                              GLenum pname,
+                                                              GLfloat* params);
+extern GL_APICALL void (*GL_APIENTRY glVertexAttribDivisor)(GLuint index,
+                                                            GLuint divisor);
+extern GL_APICALL void (*GL_APIENTRY glBindTransformFeedback)(GLenum target,
+                                                              GLuint id);
+extern GL_APICALL void (*GL_APIENTRY
+                            glDeleteTransformFeedbacks)(GLsizei n,
+                                                        const GLuint* ids);
+extern GL_APICALL void (*GL_APIENTRY glGenTransformFeedbacks)(GLsizei n,
+                                                              GLuint* ids);
+extern GL_APICALL GLboolean (*GL_APIENTRY glIsTransformFeedback)(GLuint id);
+extern GL_APICALL void (*GL_APIENTRY glPauseTransformFeedback)(void);
+extern GL_APICALL void (*GL_APIENTRY glResumeTransformFeedback)(void);
+extern GL_APICALL void (*GL_APIENTRY glGetProgramBinary)(GLuint program,
+                                                         GLsizei bufSize,
+                                                         GLsizei* length,
+                                                         GLenum* binaryFormat,
+                                                         GLvoid* binary);
+extern GL_APICALL void (*GL_APIENTRY glProgramBinary)(GLuint program,
+                                                      GLenum binaryFormat,
+                                                      const GLvoid* binary,
+                                                      GLsizei length);
+extern GL_APICALL void (*GL_APIENTRY glProgramParameteri)(GLuint program,
+                                                          GLenum pname,
+                                                          GLint value);
+extern GL_APICALL void (*GL_APIENTRY glInvalidateFramebuffer)(
+    GLenum target, GLsizei numAttachments, const GLenum* attachments);
+extern GL_APICALL void (*GL_APIENTRY glInvalidateSubFramebuffer)(
+    GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x,
+    GLint y, GLsizei width, GLsizei height);
+extern GL_APICALL void (*GL_APIENTRY
+                            glTexStorage2D)(GLenum target, GLsizei levels,
+                                            GLenum internalformat,
+                                            GLsizei width, GLsizei height);
+extern GL_APICALL void (*GL_APIENTRY glTexStorage3D)(
+    GLenum target, GLsizei levels, GLenum internalformat, GLsizei width,
+    GLsizei height, GLsizei depth);
+extern GL_APICALL void (*GL_APIENTRY glGetInternalformativ)(
+    GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize,
+    GLint* params);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

MoreTeapots/app/src/main/jni/ndk_helper/interpolator.cpp

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 "interpolator.h"
+#include <math.h>
+#include "interpolator.h"
+
+namespace ndk_helper {
+
+//-------------------------------------------------
+// Ctor
+//-------------------------------------------------
+Interpolator::Interpolator() { list_params_.clear(); }
+
+//-------------------------------------------------
+// Dtor
+//-------------------------------------------------
+Interpolator::~Interpolator() { list_params_.clear(); }
+
+void Interpolator::Clear() { list_params_.clear(); }
+
+Interpolator& Interpolator::Set(const float start, const float dest,
+                                const INTERPOLATOR_TYPE type,
+                                const double duration) {
+  // init the parameters for the interpolation process
+  start_time_ = PerfMonitor::GetCurrentTime();
+  dest_time_ = start_time_ + duration;
+  type_ = type;
+
+  start_value_ = start;
+  dest_value_ = dest;
+  return *this;
+}
+
+Interpolator& Interpolator::Add(const float dest, const INTERPOLATOR_TYPE type,
+                                const double duration) {
+  InterpolatorParams param;
+  param.dest_value_ = dest;
+  param.type_ = type;
+  param.duration_ = duration;
+  list_params_.push_back(param);
+  return *this;
+}
+
+bool Interpolator::Update(const double current_time, float& p) {
+  bool bContinue;
+  if (current_time >= dest_time_) {
+    p = dest_value_;
+    if (list_params_.size()) {
+      InterpolatorParams& item = list_params_.front();
+      Set(dest_value_, item.dest_value_, item.type_, item.duration_);
+      list_params_.pop_front();
+
+      bContinue = true;
+    } else {
+      bContinue = false;
+    }
+  } else {
+    float t = (float)(current_time - start_time_);
+    float d = (float)(dest_time_ - start_time_);
+    float b = start_value_;
+    float c = dest_value_ - start_value_;
+    p = GetFormula(type_, t, b, d, c);
+
+    bContinue = true;
+  }
+  return bContinue;
+}
+
+float Interpolator::GetFormula(const INTERPOLATOR_TYPE type, const float t,
+                               const float b, const float d, const float c) {
+  float t1;
+  switch (type) {
+    case INTERPOLATOR_TYPE_LINEAR:
+      // simple linear interpolation - no easing
+      return (c * t / d + b);
+
+    case INTERPOLATOR_TYPE_EASEINQUAD:
+      // quadratic (t^2) easing in - accelerating from zero velocity
+      t1 = t / d;
+      return (c * t1 * t1 + b);
+
+    case INTERPOLATOR_TYPE_EASEOUTQUAD:
+      // quadratic (t^2) easing out - decelerating to zero velocity
+      t1 = t / d;
+      return (-c * t1 * (t1 - 2) + b);
+
+    case INTERPOLATOR_TYPE_EASEINOUTQUAD:
+      // quadratic easing in/out - acceleration until halfway, then deceleration
+      t1 = t / d / 2;
+      if (t1 < 1)
+        return (c / 2 * t1 * t1 + b);
+      else {
+        t1 = t1 - 1;
+        return (-c / 2 * (t1 * (t1 - 2) - 1) + b);
+      }
+    case INTERPOLATOR_TYPE_EASEINCUBIC:
+      // cubic easing in - accelerating from zero velocity
+      t1 = t / d;
+      return (c * t1 * t1 * t1 + b);
+
+    case INTERPOLATOR_TYPE_EASEOUTCUBIC:
+      // cubic easing in - accelerating from zero velocity
+      t1 = t / d - 1;
+      return (c * (t1 * t1 * t1 + 1) + b);
+
+    case INTERPOLATOR_TYPE_EASEINOUTCUBIC:
+      // cubic easing in - accelerating from zero velocity
+      t1 = t / d / 2;
+
+      if (t1 < 1)
+        return (c / 2 * t1 * t1 * t1 + b);
+      else {
+        t1 -= 2;
+        return (c / 2 * (t1 * t1 * t1 + 2) + b);
+      }
+    case INTERPOLATOR_TYPE_EASEINQUART:
+      // quartic easing in - accelerating from zero velocity
+      t1 = t / d;
+      return (c * t1 * t1 * t1 * t1 + b);
+
+    case INTERPOLATOR_TYPE_EASEINEXPO:
+      // exponential (2^t) easing in - accelerating from zero velocity
+      if (t == 0)
+        return b;
+      else
+        return (c * powf(2, (10 * (t / d - 1))) + b);
+
+    case INTERPOLATOR_TYPE_EASEOUTEXPO:
+      // exponential (2^t) easing out - decelerating to zero velocity
+      if (t == d)
+        return (b + c);
+      else
+        return (c * (-powf(2, -10 * t / d) + 1) + b);
+    default:
+      return 0;
+  }
+}
+
+}  // namespace ndkHelper

MoreTeapots/app/src/main/jni/ndk_helper/interpolator.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 INTERPOLATOR_H_
+#define INTERPOLATOR_H_
+
+#include <jni.h>
+#include <errno.h>
+#include <time.h>
+#include "JNIHelper.h"
+#include "perfMonitor.h"
+#include <list>
+
+namespace ndk_helper {
+
+enum INTERPOLATOR_TYPE {
+  INTERPOLATOR_TYPE_LINEAR,
+  INTERPOLATOR_TYPE_EASEINQUAD,
+  INTERPOLATOR_TYPE_EASEOUTQUAD,
+  INTERPOLATOR_TYPE_EASEINOUTQUAD,
+  INTERPOLATOR_TYPE_EASEINCUBIC,
+  INTERPOLATOR_TYPE_EASEOUTCUBIC,
+  INTERPOLATOR_TYPE_EASEINOUTCUBIC,
+  INTERPOLATOR_TYPE_EASEINQUART,
+  INTERPOLATOR_TYPE_EASEINEXPO,
+  INTERPOLATOR_TYPE_EASEOUTEXPO,
+};
+
+struct InterpolatorParams {
+  float dest_value_;
+  INTERPOLATOR_TYPE type_;
+  double duration_;
+};
+
+/******************************************************************
+ * Interpolates values with several interpolation methods
+ */
+class Interpolator {
+ private:
+  double start_time_;
+  double dest_time_;
+  INTERPOLATOR_TYPE type_;
+
+  float start_value_;
+  float dest_value_;
+  std::list<InterpolatorParams> list_params_;
+
+  float GetFormula(const INTERPOLATOR_TYPE type, const float t, const float b,
+                   const float d, const float c);
+
+ public:
+  Interpolator();
+  ~Interpolator();
+
+  Interpolator& Set(const float start, const float dest,
+                    const INTERPOLATOR_TYPE type, double duration);
+
+  Interpolator& Add(const float dest, const INTERPOLATOR_TYPE type,
+                    const double duration);
+
+  bool Update(const double currentTime, float& p);
+
+  void Clear();
+};
+
+}  // namespace ndkHelper
+#endif /* INTERPOLATOR_H_ */

MoreTeapots/app/src/main/jni/ndk_helper/perfMonitor.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 "perfMonitor.h"
+
+namespace ndk_helper {
+
+PerfMonitor::PerfMonitor()
+    : tv_last_sec_(0), last_tick_(0.f), tickindex_(0), ticksum_(0) {
+  for (int32_t i = 0; i < NUM_SAMPLES; ++i) ticklist_[i] = 0;
+}
+
+PerfMonitor::~PerfMonitor() {}
+
+double PerfMonitor::UpdateTick(double currentTick) {
+  ticksum_ -= ticklist_[tickindex_];
+  ticksum_ += currentTick;
+  ticklist_[tickindex_] = currentTick;
+  tickindex_ = (tickindex_ + 1) % NUM_SAMPLES;
+
+  return ((double)ticksum_ / NUM_SAMPLES);
+}
+
+bool PerfMonitor::Update(float &fFPS) {
+  struct timeval Time;
+  gettimeofday(&Time, NULL);
+
+  double time = Time.tv_sec + Time.tv_usec * 1.0 / 1000000.0;
+  double tick = time - last_tick_;
+  double d = UpdateTick(tick);
+  last_tick_ = time;
+
+  if (Time.tv_sec - tv_last_sec_ >= 1) {
+    current_FPS_ = 1.f / d;
+    tv_last_sec_ = Time.tv_sec;
+    fFPS = current_FPS_;
+    return true;
+  } else {
+    fFPS = current_FPS_;
+    return false;
+  }
+}
+
+}  // namespace ndkHelper

MoreTeapots/app/src/main/jni/ndk_helper/perfMonitor.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 PERFMONITOR_H_
+#define PERFMONITOR_H_
+
+#include <jni.h>
+#include <errno.h>
+#include <time.h>
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+const int32_t NUM_SAMPLES = 100;
+
+/******************************************************************
+ * Helper class for a performance monitoring and get current tick time
+ */
+class PerfMonitor {
+ private:
+  float current_FPS_;
+  time_t tv_last_sec_;
+
+  double last_tick_;
+  int32_t tickindex_;
+  double ticksum_;
+  double ticklist_[NUM_SAMPLES];
+
+  double UpdateTick(double current_tick);
+
+ public:
+  PerfMonitor();
+  virtual ~PerfMonitor();
+
+  bool Update(float &fFPS);
+
+  static double GetCurrentTime() {
+    struct timeval time;
+    gettimeofday(&time, NULL);
+    double ret = time.tv_sec + time.tv_usec * 1.0 / 1000000.0;
+    return ret;
+  }
+};
+
+}  // namespace ndkHelper
+#endif /* PERFMONITOR_H_ */

MoreTeapots/app/src/main/jni/ndk_helper/shader.cpp

@@ -0,0 +1,167 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 <EGL/egl.h>
+#include <GLES2/gl2.h>
+
+#include "shader.h"
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+#define DEBUG (1)
+
+bool shader::CompileShader(
+    GLuint *shader, const GLenum type, const char *str_file_name,
+    const std::map<std::string, std::string> &map_parameters) {
+  std::vector<uint8_t> data;
+  if (!JNIHelper::GetInstance()->ReadFile(str_file_name, &data)) {
+    LOGI("Can not open a file:%s", str_file_name);
+    return false;
+  }
+
+  const char REPLACEMENT_TAG = '*';
+  // Fill-in parameters
+  std::string str(data.begin(), data.end());
+  std::string str_replacement_map(data.size(), ' ');
+
+  std::map<std::string, std::string>::const_iterator it =
+      map_parameters.begin();
+  std::map<std::string, std::string>::const_iterator itEnd =
+      map_parameters.end();
+  while (it != itEnd) {
+    size_t pos = 0;
+    while ((pos = str.find(it->first, pos)) != std::string::npos) {
+      // Check if the sub string is already touched
+
+      size_t replaced_pos = str_replacement_map.find(REPLACEMENT_TAG, pos);
+      if (replaced_pos == std::string::npos || replaced_pos > pos) {
+
+        str.replace(pos, it->first.length(), it->second);
+        str_replacement_map.replace(pos, it->first.length(), it->first.length(),
+                                    REPLACEMENT_TAG);
+        pos += it->second.length();
+      } else {
+        // The replacement target has been touched by other tag, skipping them
+        pos += it->second.length();
+      }
+    }
+    it++;
+  }
+
+  LOGI("Patched Shdader:\n%s", str.c_str());
+
+  std::vector<uint8_t> v(str.begin(), str.end());
+  str.clear();
+  return shader::CompileShader(shader, type, v);
+}
+
+bool shader::CompileShader(GLuint *shader, const GLenum type,
+                           const GLchar *source, const int32_t iSize) {
+  if (source == NULL || iSize <= 0) return false;
+
+  *shader = glCreateShader(type);
+  glShaderSource(*shader, 1, &source, &iSize);  // Not specifying 3rd parameter
+                                                // (size) could be troublesome..
+
+  glCompileShader(*shader);
+
+#if defined(DEBUG)
+  GLint logLength;
+  glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength);
+  if (logLength > 0) {
+    GLchar *log = (GLchar *)malloc(logLength);
+    glGetShaderInfoLog(*shader, logLength, &logLength, log);
+    LOGI("Shader compile log:\n%s", log);
+    free(log);
+  }
+#endif
+
+  GLint status;
+  glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);
+  if (status == 0) {
+    glDeleteShader(*shader);
+    return false;
+  }
+
+  return true;
+}
+
+bool shader::CompileShader(GLuint *shader, const GLenum type,
+                           std::vector<uint8_t> &data) {
+  if (!data.size()) return false;
+
+  const GLchar *source = (GLchar *)&data[0];
+  int32_t iSize = data.size();
+  return shader::CompileShader(shader, type, source, iSize);
+}
+
+bool shader::CompileShader(GLuint *shader, const GLenum type,
+                           const char *strFileName) {
+  std::vector<uint8_t> data;
+  bool b = JNIHelper::GetInstance()->ReadFile(strFileName, &data);
+  if (!b) {
+    LOGI("Can not open a file:%s", strFileName);
+    return false;
+  }
+
+  return shader::CompileShader(shader, type, data);
+}
+
+bool shader::LinkProgram(const GLuint prog) {
+  GLint status;
+
+  glLinkProgram(prog);
+
+#if defined(DEBUG)
+  GLint logLength;
+  glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLength);
+  if (logLength > 0) {
+    GLchar *log = (GLchar *)malloc(logLength);
+    glGetProgramInfoLog(prog, logLength, &logLength, log);
+    LOGI("Program link log:\n%s", log);
+    free(log);
+  }
+#endif
+
+  glGetProgramiv(prog, GL_LINK_STATUS, &status);
+  if (status == 0) {
+    LOGI("Program link failed\n");
+    return false;
+  }
+
+  return true;
+}
+
+bool shader::ValidateProgram(const GLuint prog) {
+  GLint logLength, status;
+
+  glValidateProgram(prog);
+  glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLength);
+  if (logLength > 0) {
+    GLchar *log = (GLchar *)malloc(logLength);
+    glGetProgramInfoLog(prog, logLength, &logLength, log);
+    LOGI("Program validate log:\n%s", log);
+    free(log);
+  }
+
+  glGetProgramiv(prog, GL_VALIDATE_STATUS, &status);
+  if (status == 0) return false;
+
+  return true;
+}
+
+}  // namespace ndkHelper

MoreTeapots/app/src/main/jni/ndk_helper/shader.h

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 SHADER_H_
+#define SHADER_H_
+
+#include <jni.h>
+
+#include <vector>
+#include <map>
+#include <string>
+
+#include <EGL/egl.h>
+#include <GLES/gl.h>
+
+#include <android/log.h>
+
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+namespace shader {
+
+/******************************************************************
+ * Shader compiler helper
+ * namespace: ndkHelper::shader
+ *
+ */
+
+/******************************************************************
+ * CompileShader() with vector
+ *
+ * arguments:
+ *  out: shader, shader variable
+ *  in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
+ *  in: data, source vector
+ * return: true if a shader compilation succeeded, false if it failed
+ *
+ */
+bool CompileShader(GLuint *shader, const GLenum type,
+                   std::vector<uint8_t> &data);
+
+/******************************************************************
+ * CompileShader() with buffer
+ *
+ * arguments:
+ *  out: shader, shader variable
+ *  in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
+ *  in: source, source buffer
+ *  in: iSize, buffer size
+ * return: true if a shader compilation succeeded, false if it failed
+ *
+ */
+bool CompileShader(GLuint *shader, const GLenum type, const GLchar *source,
+                   const int32_t iSize);
+
+/******************************************************************
+ * CompileShader() with filename
+ *
+ * arguments:
+ *  out: shader, shader variable
+ *  in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
+ *  in: strFilename, filename
+ * return: true if a shader compilation succeeded, false if it failed
+ *
+ */
+bool CompileShader(GLuint *shader, const GLenum type, const char *strFileName);
+
+/******************************************************************
+ * CompileShader() with std::map helps patching on a shader on the fly.
+ *
+ * arguments:
+ *  out: shader, shader variable
+ *  in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
+ *  in: mapParameters
+ *      For a example,
+ *      map : %KEY% -> %VALUE% replaces all %KEY% entries in the given shader
+ *code to %VALUE"
+ * return: true if a shader compilation succeeded, false if it failed
+ *
+ */
+bool CompileShader(GLuint *shader, const GLenum type, const char *str_file_name,
+                   const std::map<std::string, std::string> &map_parameters);
+
+/******************************************************************
+ * LinkProgram()
+ *
+ * arguments:
+ *  in: program, program
+ * return: true if a shader linkage succeeded, false if it failed
+ *
+ */
+bool LinkProgram(const GLuint prog);
+
+/******************************************************************
+ * validateProgram()
+ *
+ * arguments:
+ *  in: program, program
+ * return: true if a shader validation succeeded, false if it failed
+ *
+ */
+bool ValidateProgram(const GLuint prog);
+}  // namespace shader
+
+}  // namespace ndkHelper
+#endif /* SHADER_H_ */

MoreTeapots/app/src/main/jni/ndk_helper/tapCamera.cpp

@@ -0,0 +1,281 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//----------------------------------------------------------
+//  tapCamera.cpp
+//  Camera control with tap
+//
+//----------------------------------------------------------
+#include <fstream>
+#include "tapCamera.h"
+
+namespace ndk_helper {
+
+const float TRANSFORM_FACTOR = 15.f;
+const float TRANSFORM_FACTORZ = 10.f;
+
+const float MOMENTUM_FACTOR_DECREASE = 0.85f;
+const float MOMENTUM_FACTOR_DECREASE_SHIFT = 0.9f;
+const float MOMENTUM_FACTOR = 0.8f;
+const float MOMENTUM_FACTOR_THRESHOLD = 0.001f;
+
+//----------------------------------------------------------
+//  Ctor
+//----------------------------------------------------------
+TapCamera::TapCamera()
+    : ball_radius_(0.75f),
+      dragging_(false),
+      pinching_(false),
+      pinch_start_distance_SQ_(0.f),
+      camera_rotation_(0.f),
+      camera_rotation_start_(0.f),
+      camera_rotation_now_(0.f),
+      momentum_(false),
+      momemtum_steps_(0.f),
+      flip_z_(0.f) {
+  // Init offset
+  InitParameters();
+
+  vec_flip_ = Vec2(1.f, -1.f);
+  flip_z_ = -1.f;
+  vec_pinch_transform_factor_ = Vec3(1.f, 1.f, 1.f);
+
+  vec_ball_center_ = Vec2(0, 0);
+  vec_ball_now_ = Vec2(0, 0);
+  vec_ball_down_ = Vec2(0, 0);
+
+  vec_pinch_start_ = Vec2(0, 0);
+  vec_pinch_start_center_ = Vec2(0, 0);
+
+  vec_flip_ = Vec2(0, 0);
+}
+
+void TapCamera::InitParameters() {
+  // Init parameters
+  vec_offset_ = Vec3();
+  vec_offset_now_ = Vec3();
+
+  quat_ball_rot_ = Quaternion();
+  quat_ball_now_ = Quaternion();
+  quat_ball_now_.ToMatrix(mat_rotation_);
+  camera_rotation_ = 0.f;
+
+  vec_drag_delta_ = Vec2();
+  vec_offset_delta_ = Vec3();
+
+  momentum_ = false;
+}
+
+//----------------------------------------------------------
+//  Dtor
+//----------------------------------------------------------
+TapCamera::~TapCamera() {}
+
+void TapCamera::Update() {
+  if (momentum_) {
+    float momenttum_steps = momemtum_steps_;
+
+    // Momentum rotation
+    Vec2 v = vec_drag_delta_;
+    BeginDrag(Vec2());  // NOTE:This call reset _VDragDelta
+    Drag(v * vec_flip_);
+
+    // Momentum shift
+    vec_offset_ += vec_offset_delta_;
+
+    BallUpdate();
+    EndDrag();
+
+    // Decrease deltas
+    vec_drag_delta_ = v * MOMENTUM_FACTOR_DECREASE;
+    vec_offset_delta_ = vec_offset_delta_ * MOMENTUM_FACTOR_DECREASE_SHIFT;
+
+    // Count steps
+    momemtum_steps_ = momenttum_steps * MOMENTUM_FACTOR_DECREASE;
+    if (momemtum_steps_ < MOMENTUM_FACTOR_THRESHOLD) {
+      momentum_ = false;
+    }
+  } else {
+    vec_drag_delta_ *= MOMENTUM_FACTOR;
+    vec_offset_delta_ = vec_offset_delta_ * MOMENTUM_FACTOR;
+    BallUpdate();
+  }
+
+  Vec3 vec = vec_offset_ + vec_offset_now_;
+  Vec3 vec_tmp(TRANSFORM_FACTOR, -TRANSFORM_FACTOR, TRANSFORM_FACTORZ);
+
+  vec *= vec_tmp * vec_pinch_transform_factor_;
+
+  mat_transform_ = Mat4::Translation(vec);
+}
+
+Mat4& TapCamera::GetRotationMatrix() { return mat_rotation_; }
+
+Mat4& TapCamera::GetTransformMatrix() { return mat_transform_; }
+
+void TapCamera::Reset(const bool bAnimate) {
+  InitParameters();
+  Update();
+}
+
+//----------------------------------------------------------
+// Drag control
+//----------------------------------------------------------
+void TapCamera::BeginDrag(const Vec2& v) {
+  if (dragging_) EndDrag();
+
+  if (pinching_) EndPinch();
+
+  Vec2 vec = v * vec_flip_;
+  vec_ball_now_ = vec;
+  vec_ball_down_ = vec_ball_now_;
+
+  dragging_ = true;
+  momentum_ = false;
+  vec_last_input_ = vec;
+  vec_drag_delta_ = Vec2();
+}
+
+void TapCamera::EndDrag() {
+  quat_ball_down_ = quat_ball_now_;
+  quat_ball_rot_ = Quaternion();
+
+  dragging_ = false;
+  momentum_ = true;
+  momemtum_steps_ = 1.0f;
+}
+
+void TapCamera::Drag(const Vec2& v) {
+  if (!dragging_) return;
+
+  Vec2 vec = v * vec_flip_;
+  vec_ball_now_ = vec;
+
+  vec_drag_delta_ = vec_drag_delta_ * MOMENTUM_FACTOR + (vec - vec_last_input_);
+  vec_last_input_ = vec;
+}
+
+//----------------------------------------------------------
+// Pinch controll
+//----------------------------------------------------------
+void TapCamera::BeginPinch(const Vec2& v1, const Vec2& v2) {
+  if (dragging_) EndDrag();
+
+  if (pinching_) EndPinch();
+
+  BeginDrag(Vec2());
+
+  vec_pinch_start_center_ = (v1 + v2) / 2.f;
+
+  Vec2 vec = v1 - v2;
+  float x_diff;
+  float y_diff;
+  vec.Value(x_diff, y_diff);
+
+  pinch_start_distance_SQ_ = x_diff * x_diff + y_diff * y_diff;
+  camera_rotation_start_ = atan2f(y_diff, x_diff);
+  camera_rotation_now_ = 0;
+
+  pinching_ = true;
+  momentum_ = false;
+
+  // Init momentum factors
+  vec_offset_delta_ = Vec3();
+}
+
+void TapCamera::EndPinch() {
+  pinching_ = false;
+  momentum_ = true;
+  momemtum_steps_ = 1.f;
+  vec_offset_ += vec_offset_now_;
+  camera_rotation_ += camera_rotation_now_;
+  vec_offset_now_ = Vec3();
+
+  camera_rotation_now_ = 0;
+
+  EndDrag();
+}
+
+void TapCamera::Pinch(const Vec2& v1, const Vec2& v2) {
+  if (!pinching_) return;
+
+  // Update momentum factor
+  vec_offset_last_ = vec_offset_now_;
+
+  float x_diff, y_diff;
+  Vec2 vec = v1 - v2;
+  vec.Value(x_diff, y_diff);
+
+  float fDistanceSQ = x_diff * x_diff + y_diff * y_diff;
+
+  float f = pinch_start_distance_SQ_ / fDistanceSQ;
+  if (f < 1.f)
+    f = -1.f / f + 1.0f;
+  else
+    f = f - 1.f;
+  if (isnan(f)) f = 0.f;
+
+  vec = (v1 + v2) / 2.f - vec_pinch_start_center_;
+  vec_offset_now_ = Vec3(vec, flip_z_ * f);
+
+  // Update momentum factor
+  vec_offset_delta_ = vec_offset_delta_ * MOMENTUM_FACTOR +
+                      (vec_offset_now_ - vec_offset_last_);
+
+  //
+  // Update ration quaternion
+  float fRotation = atan2f(y_diff, x_diff);
+  camera_rotation_now_ = fRotation - camera_rotation_start_;
+
+  // Trackball rotation
+  quat_ball_rot_ = Quaternion(0.f, 0.f, sinf(-camera_rotation_now_ * 0.5f),
+                              cosf(-camera_rotation_now_ * 0.5f));
+}
+
+//----------------------------------------------------------
+// Trackball controll
+//----------------------------------------------------------
+void TapCamera::BallUpdate() {
+  if (dragging_) {
+    Vec3 vec_from = PointOnSphere(vec_ball_down_);
+    Vec3 vec_to = PointOnSphere(vec_ball_now_);
+
+    Vec3 vec = vec_from.Cross(vec_to);
+    float w = vec_from.Dot(vec_to);
+
+    Quaternion qDrag = Quaternion(vec, w);
+    qDrag = qDrag * quat_ball_down_;
+    quat_ball_now_ = quat_ball_rot_ * qDrag;
+  }
+  quat_ball_now_.ToMatrix(mat_rotation_);
+}
+
+Vec3 TapCamera::PointOnSphere(Vec2& point) {
+  Vec3 ball_mouse;
+  float mag;
+  Vec2 vec = (point - vec_ball_center_) / ball_radius_;
+  mag = vec.Dot(vec);
+  if (mag > 1.f) {
+    float scale = 1.f / sqrtf(mag);
+    vec *= scale;
+    ball_mouse = Vec3(vec, 0.f);
+  } else {
+    ball_mouse = Vec3(vec, sqrtf(1.f - mag));
+  }
+  return ball_mouse;
+}
+
+}  // namespace ndkHelper

MoreTeapots/app/src/main/jni/ndk_helper/tapCamera.h

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+#include <vector>
+#include <string>
+#include <GLES2/gl2.h>
+
+#include "JNIHelper.h"
+#include "vecmath.h"
+#include "interpolator.h"
+
+namespace ndk_helper {
+
+/******************************************************************
+ * Camera control helper class with a tap gesture
+ * This class is mainly used for 3D space camera control in samples.
+ *
+ */
+class TapCamera {
+ private:
+  // Trackball
+  Vec2 vec_ball_center_;
+  float ball_radius_;
+  Quaternion quat_ball_now_;
+  Quaternion quat_ball_down_;
+  Vec2 vec_ball_now_;
+  Vec2 vec_ball_down_;
+  Quaternion quat_ball_rot_;
+
+  bool dragging_;
+  bool pinching_;
+
+  // Pinch related info
+  Vec2 vec_pinch_start_;
+  Vec2 vec_pinch_start_center_;
+  float pinch_start_distance_SQ_;
+
+  // Camera shift
+  Vec3 vec_offset_;
+  Vec3 vec_offset_now_;
+
+  // Camera Rotation
+  float camera_rotation_;
+  float camera_rotation_start_;
+  float camera_rotation_now_;
+
+  // Momentum support
+  bool momentum_;
+  Vec2 vec_drag_delta_;
+  Vec2 vec_last_input_;
+  Vec3 vec_offset_last_;
+  Vec3 vec_offset_delta_;
+  float momemtum_steps_;
+
+  Vec2 vec_flip_;
+  float flip_z_;
+
+  Mat4 mat_rotation_;
+  Mat4 mat_transform_;
+
+  Vec3 vec_pinch_transform_factor_;
+
+  Vec3 PointOnSphere(Vec2& point);
+  void BallUpdate();
+  void InitParameters();
+
+ public:
+  TapCamera();
+  virtual ~TapCamera();
+  void BeginDrag(const Vec2& vec);
+  void EndDrag();
+  void Drag(const Vec2& vec);
+  void Update();
+
+  Mat4& GetRotationMatrix();
+  Mat4& GetTransformMatrix();
+
+  void BeginPinch(const Vec2& v1, const Vec2& v2);
+  void EndPinch();
+  void Pinch(const Vec2& v1, const Vec2& v2);
+
+  void SetFlip(const float x, const float y, const float z) {
+    vec_flip_ = Vec2(x, y);
+    flip_z_ = z;
+  }
+
+  void SetPinchTransformFactor(const float x, const float y, const float z) {
+    vec_pinch_transform_factor_ = Vec3(x, y, z);
+  }
+
+  void Reset(const bool bAnimate);
+};
+
+}  // namespace ndkHelper

MoreTeapots/app/src/main/jni/ndk_helper/vecmath.cpp

@@ -0,0 +1,362 @@
+/*
+ * Copy_right 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * y_ou may_ not use this file ex_cept 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 ex_press or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//--------------------------------------------------------------------------------
+// vecmath.cpp
+//--------------------------------------------------------------------------------
+#include "vecmath.h"
+
+namespace ndk_helper {
+
+//--------------------------------------------------------------------------------
+// vec3
+//--------------------------------------------------------------------------------
+Vec3::Vec3(const Vec4& vec) {
+  x_ = vec.x_;
+  y_ = vec.y_;
+  z_ = vec.z_;
+}
+
+//--------------------------------------------------------------------------------
+// vec4
+//--------------------------------------------------------------------------------
+Vec4 Vec4::operator*(const Mat4& rhs) const {
+  Vec4 out;
+  out.x_ = x_ * rhs.f_[0] + y_ * rhs.f_[1] + z_ * rhs.f_[2] + w_ * rhs.f_[3];
+  out.y_ = x_ * rhs.f_[4] + y_ * rhs.f_[5] + z_ * rhs.f_[6] + w_ * rhs.f_[7];
+  out.z_ = x_ * rhs.f_[8] + y_ * rhs.f_[9] + z_ * rhs.f_[10] + w_ * rhs.f_[11];
+  out.w_ =
+      x_ * rhs.f_[12] + y_ * rhs.f_[13] + z_ * rhs.f_[14] + w_ * rhs.f_[15];
+  return out;
+}
+
+//--------------------------------------------------------------------------------
+// mat4
+//--------------------------------------------------------------------------------
+Mat4::Mat4() {
+  for (int32_t i = 0; i < 16; ++i) f_[i] = 0.f;
+}
+
+Mat4::Mat4(const float* mIn) {
+  for (int32_t i = 0; i < 16; ++i) f_[i] = mIn[i];
+}
+
+Mat4 Mat4::operator*(const Mat4& rhs) const {
+  Mat4 ret;
+  ret.f_[0] = f_[0] * rhs.f_[0] + f_[4] * rhs.f_[1] + f_[8] * rhs.f_[2] +
+              f_[12] * rhs.f_[3];
+  ret.f_[1] = f_[1] * rhs.f_[0] + f_[5] * rhs.f_[1] + f_[9] * rhs.f_[2] +
+              f_[13] * rhs.f_[3];
+  ret.f_[2] = f_[2] * rhs.f_[0] + f_[6] * rhs.f_[1] + f_[10] * rhs.f_[2] +
+              f_[14] * rhs.f_[3];
+  ret.f_[3] = f_[3] * rhs.f_[0] + f_[7] * rhs.f_[1] + f_[11] * rhs.f_[2] +
+              f_[15] * rhs.f_[3];
+
+  ret.f_[4] = f_[0] * rhs.f_[4] + f_[4] * rhs.f_[5] + f_[8] * rhs.f_[6] +
+              f_[12] * rhs.f_[7];
+  ret.f_[5] = f_[1] * rhs.f_[4] + f_[5] * rhs.f_[5] + f_[9] * rhs.f_[6] +
+              f_[13] * rhs.f_[7];
+  ret.f_[6] = f_[2] * rhs.f_[4] + f_[6] * rhs.f_[5] + f_[10] * rhs.f_[6] +
+              f_[14] * rhs.f_[7];
+  ret.f_[7] = f_[3] * rhs.f_[4] + f_[7] * rhs.f_[5] + f_[11] * rhs.f_[6] +
+              f_[15] * rhs.f_[7];
+
+  ret.f_[8] = f_[0] * rhs.f_[8] + f_[4] * rhs.f_[9] + f_[8] * rhs.f_[10] +
+              f_[12] * rhs.f_[11];
+  ret.f_[9] = f_[1] * rhs.f_[8] + f_[5] * rhs.f_[9] + f_[9] * rhs.f_[10] +
+              f_[13] * rhs.f_[11];
+  ret.f_[10] = f_[2] * rhs.f_[8] + f_[6] * rhs.f_[9] + f_[10] * rhs.f_[10] +
+               f_[14] * rhs.f_[11];
+  ret.f_[11] = f_[3] * rhs.f_[8] + f_[7] * rhs.f_[9] + f_[11] * rhs.f_[10] +
+               f_[15] * rhs.f_[11];
+
+  ret.f_[12] = f_[0] * rhs.f_[12] + f_[4] * rhs.f_[13] + f_[8] * rhs.f_[14] +
+               f_[12] * rhs.f_[15];
+  ret.f_[13] = f_[1] * rhs.f_[12] + f_[5] * rhs.f_[13] + f_[9] * rhs.f_[14] +
+               f_[13] * rhs.f_[15];
+  ret.f_[14] = f_[2] * rhs.f_[12] + f_[6] * rhs.f_[13] + f_[10] * rhs.f_[14] +
+               f_[14] * rhs.f_[15];
+  ret.f_[15] = f_[3] * rhs.f_[12] + f_[7] * rhs.f_[13] + f_[11] * rhs.f_[14] +
+               f_[15] * rhs.f_[15];
+
+  return ret;
+}
+
+Vec4 Mat4::operator*(const Vec4& rhs) const {
+  Vec4 ret;
+  ret.x_ = rhs.x_ * f_[0] + rhs.y_ * f_[4] + rhs.z_ * f_[8] + rhs.w_ * f_[12];
+  ret.y_ = rhs.x_ * f_[1] + rhs.y_ * f_[5] + rhs.z_ * f_[9] + rhs.w_ * f_[13];
+  ret.z_ = rhs.x_ * f_[2] + rhs.y_ * f_[6] + rhs.z_ * f_[10] + rhs.w_ * f_[14];
+  ret.w_ = rhs.x_ * f_[3] + rhs.y_ * f_[7] + rhs.z_ * f_[11] + rhs.w_ * f_[15];
+  return ret;
+}
+
+Mat4 Mat4::Inverse() {
+  Mat4 ret;
+  float det_1;
+  float pos = 0;
+  float neg = 0;
+  float temp;
+
+  temp = f_[0] * f_[5] * f_[10];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  temp = f_[4] * f_[9] * f_[2];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  temp = f_[8] * f_[1] * f_[6];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  temp = -f_[8] * f_[5] * f_[2];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  temp = -f_[4] * f_[1] * f_[10];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  temp = -f_[0] * f_[9] * f_[6];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  det_1 = pos + neg;
+
+  if (det_1 == 0.0) {
+    // Error
+  } else {
+    det_1 = 1.0f / det_1;
+    ret.f_[0] = (f_[5] * f_[10] - f_[9] * f_[6]) * det_1;
+    ret.f_[1] = -(f_[1] * f_[10] - f_[9] * f_[2]) * det_1;
+    ret.f_[2] = (f_[1] * f_[6] - f_[5] * f_[2]) * det_1;
+    ret.f_[4] = -(f_[4] * f_[10] - f_[8] * f_[6]) * det_1;
+    ret.f_[5] = (f_[0] * f_[10] - f_[8] * f_[2]) * det_1;
+    ret.f_[6] = -(f_[0] * f_[6] - f_[4] * f_[2]) * det_1;
+    ret.f_[8] = (f_[4] * f_[9] - f_[8] * f_[5]) * det_1;
+    ret.f_[9] = -(f_[0] * f_[9] - f_[8] * f_[1]) * det_1;
+    ret.f_[10] = (f_[0] * f_[5] - f_[4] * f_[1]) * det_1;
+
+    /* Calculate -C * inverse(A) */
+    ret.f_[12] =
+        -(f_[12] * ret.f_[0] + f_[13] * ret.f_[4] + f_[14] * ret.f_[8]);
+    ret.f_[13] =
+        -(f_[12] * ret.f_[1] + f_[13] * ret.f_[5] + f_[14] * ret.f_[9]);
+    ret.f_[14] =
+        -(f_[12] * ret.f_[2] + f_[13] * ret.f_[6] + f_[14] * ret.f_[10]);
+
+    ret.f_[3] = 0.0f;
+    ret.f_[7] = 0.0f;
+    ret.f_[11] = 0.0f;
+    ret.f_[15] = 1.0f;
+  }
+
+  *this = ret;
+  return *this;
+}
+
+//--------------------------------------------------------------------------------
+// Misc
+//--------------------------------------------------------------------------------
+Mat4 Mat4::RotationX(const float fAngle) {
+  Mat4 ret;
+  float fCosine, fSine;
+
+  fCosine = cosf(fAngle);
+  fSine = sinf(fAngle);
+
+  ret.f_[0] = 1.0f;
+  ret.f_[4] = 0.0f;
+  ret.f_[8] = 0.0f;
+  ret.f_[12] = 0.0f;
+  ret.f_[1] = 0.0f;
+  ret.f_[5] = fCosine;
+  ret.f_[9] = fSine;
+  ret.f_[13] = 0.0f;
+  ret.f_[2] = 0.0f;
+  ret.f_[6] = -fSine;
+  ret.f_[10] = fCosine;
+  ret.f_[14] = 0.0f;
+  ret.f_[3] = 0.0f;
+  ret.f_[7] = 0.0f;
+  ret.f_[11] = 0.0f;
+  ret.f_[15] = 1.0f;
+  return ret;
+}
+
+Mat4 Mat4::RotationY(const float fAngle) {
+  Mat4 ret;
+  float fCosine, fSine;
+
+  fCosine = cosf(fAngle);
+  fSine = sinf(fAngle);
+
+  ret.f_[0] = fCosine;
+  ret.f_[4] = 0.0f;
+  ret.f_[8] = -fSine;
+  ret.f_[12] = 0.0f;
+  ret.f_[1] = 0.0f;
+  ret.f_[5] = 1.0f;
+  ret.f_[9] = 0.0f;
+  ret.f_[13] = 0.0f;
+  ret.f_[2] = fSine;
+  ret.f_[6] = 0.0f;
+  ret.f_[10] = fCosine;
+  ret.f_[14] = 0.0f;
+  ret.f_[3] = 0.0f;
+  ret.f_[7] = 0.0f;
+  ret.f_[11] = 0.0f;
+  ret.f_[15] = 1.0f;
+  return ret;
+}
+
+Mat4 Mat4::RotationZ(const float fAngle) {
+  Mat4 ret;
+  float fCosine, fSine;
+
+  fCosine = cosf(fAngle);
+  fSine = sinf(fAngle);
+
+  ret.f_[0] = fCosine;
+  ret.f_[4] = fSine;
+  ret.f_[8] = 0.0f;
+  ret.f_[12] = 0.0f;
+  ret.f_[1] = -fSine;
+  ret.f_[5] = fCosine;
+  ret.f_[9] = 0.0f;
+  ret.f_[13] = 0.0f;
+  ret.f_[2] = 0.0f;
+  ret.f_[6] = 0.0f;
+  ret.f_[10] = 1.0f;
+  ret.f_[14] = 0.0f;
+  ret.f_[3] = 0.0f;
+  ret.f_[7] = 0.0f;
+  ret.f_[11] = 0.0f;
+  ret.f_[15] = 1.0f;
+  return ret;
+}
+
+Mat4 Mat4::Translation(const float fX, const float fY, const float fZ) {
+  Mat4 ret;
+  ret.f_[0] = 1.0f;
+  ret.f_[4] = 0.0f;
+  ret.f_[8] = 0.0f;
+  ret.f_[12] = fX;
+  ret.f_[1] = 0.0f;
+  ret.f_[5] = 1.0f;
+  ret.f_[9] = 0.0f;
+  ret.f_[13] = fY;
+  ret.f_[2] = 0.0f;
+  ret.f_[6] = 0.0f;
+  ret.f_[10] = 1.0f;
+  ret.f_[14] = fZ;
+  ret.f_[3] = 0.0f;
+  ret.f_[7] = 0.0f;
+  ret.f_[11] = 0.0f;
+  ret.f_[15] = 1.0f;
+  return ret;
+}
+
+Mat4 Mat4::Translation(const Vec3 vec) {
+  Mat4 ret;
+  ret.f_[0] = 1.0f;
+  ret.f_[4] = 0.0f;
+  ret.f_[8] = 0.0f;
+  ret.f_[12] = vec.x_;
+  ret.f_[1] = 0.0f;
+  ret.f_[5] = 1.0f;
+  ret.f_[9] = 0.0f;
+  ret.f_[13] = vec.y_;
+  ret.f_[2] = 0.0f;
+  ret.f_[6] = 0.0f;
+  ret.f_[10] = 1.0f;
+  ret.f_[14] = vec.z_;
+  ret.f_[3] = 0.0f;
+  ret.f_[7] = 0.0f;
+  ret.f_[11] = 0.0f;
+  ret.f_[15] = 1.0f;
+  return ret;
+}
+
+Mat4 Mat4::Perspective(float width, float height, float nearPlane,
+                       float farPlane) {
+  float n2 = 2.0f * nearPlane;
+  float rcpnmf = 1.f / (nearPlane - farPlane);
+
+  Mat4 result;
+  result.f_[0] = n2 / width;
+  result.f_[4] = 0;
+  result.f_[8] = 0;
+  result.f_[12] = 0;
+  result.f_[1] = 0;
+  result.f_[5] = n2 / height;
+  result.f_[9] = 0;
+  result.f_[13] = 0;
+  result.f_[2] = 0;
+  result.f_[6] = 0;
+  result.f_[10] = (farPlane + nearPlane) * rcpnmf;
+  result.f_[14] = farPlane * rcpnmf * n2;
+  result.f_[3] = 0;
+  result.f_[7] = 0;
+  result.f_[11] = -1.0;
+  result.f_[15] = 0;
+
+  return result;
+}
+
+Mat4 Mat4::LookAt(const Vec3& vec_eye, const Vec3& vec_at, const Vec3& vec_up) {
+  Vec3 vec_forward, vec_up_norm, vec_side;
+  Mat4 result;
+
+  vec_forward.x_ = vec_eye.x_ - vec_at.x_;
+  vec_forward.y_ = vec_eye.y_ - vec_at.y_;
+  vec_forward.z_ = vec_eye.z_ - vec_at.z_;
+
+  vec_forward.Normalize();
+  vec_up_norm = vec_up;
+  vec_up_norm.Normalize();
+  vec_side = vec_up_norm.Cross(vec_forward);
+  vec_up_norm = vec_forward.Cross(vec_side);
+
+  result.f_[0] = vec_side.x_;
+  result.f_[4] = vec_side.y_;
+  result.f_[8] = vec_side.z_;
+  result.f_[12] = 0;
+  result.f_[1] = vec_up_norm.x_;
+  result.f_[5] = vec_up_norm.y_;
+  result.f_[9] = vec_up_norm.z_;
+  result.f_[13] = 0;
+  result.f_[2] = vec_forward.x_;
+  result.f_[6] = vec_forward.y_;
+  result.f_[10] = vec_forward.z_;
+  result.f_[14] = 0;
+  result.f_[3] = 0;
+  result.f_[7] = 0;
+  result.f_[11] = 0;
+  result.f_[15] = 1.0;
+
+  result.PostTranslate(-vec_eye.x_, -vec_eye.y_, -vec_eye.z_);
+  return result;
+}
+
+}  // namespace ndkHelper

MoreTeapots/app/src/main/jni/ndk_helper/vecmath.h

@@ -0,0 +1,959 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 VECMATH_H_
+#define VECMATH_H_
+
+#include <math.h>
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+/******************************************************************
+ * Helper class for vector math operations
+ * Currently all implementations are in pure C++.
+ * Each class is an opaque class so caller does not have a direct access
+ * to each element. This is for an ease of future optimization to use vector
+ *operations.
+ *
+ */
+
+class Vec2;
+class Vec3;
+class Vec4;
+class Mat4;
+
+/******************************************************************
+ * 2 elements vector class
+ *
+ */
+class Vec2 {
+ private:
+  float x_;
+  float y_;
+
+ public:
+  friend class Vec3;
+  friend class Vec4;
+  friend class Mat4;
+  friend class Quaternion;
+
+  Vec2() { x_ = y_ = 0.f; }
+
+  Vec2(const float fX, const float fY) {
+    x_ = fX;
+    y_ = fY;
+  }
+
+  Vec2(const Vec2& vec) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+  }
+
+  Vec2(const float* pVec) {
+    x_ = (*pVec++);
+    y_ = (*pVec++);
+  }
+
+  // Operators
+  Vec2 operator*(const Vec2& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ * rhs.x_;
+    ret.y_ = y_ * rhs.y_;
+    return ret;
+  }
+
+  Vec2 operator/(const Vec2& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ / rhs.x_;
+    ret.y_ = y_ / rhs.y_;
+    return ret;
+  }
+
+  Vec2 operator+(const Vec2& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ + rhs.x_;
+    ret.y_ = y_ + rhs.y_;
+    return ret;
+  }
+
+  Vec2 operator-(const Vec2& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ - rhs.x_;
+    ret.y_ = y_ - rhs.y_;
+    return ret;
+  }
+
+  Vec2& operator+=(const Vec2& rhs) {
+    x_ += rhs.x_;
+    y_ += rhs.y_;
+    return *this;
+  }
+
+  Vec2& operator-=(const Vec2& rhs) {
+    x_ -= rhs.x_;
+    y_ -= rhs.y_;
+    return *this;
+  }
+
+  Vec2& operator*=(const Vec2& rhs) {
+    x_ *= rhs.x_;
+    y_ *= rhs.y_;
+    return *this;
+  }
+
+  Vec2& operator/=(const Vec2& rhs) {
+    x_ /= rhs.x_;
+    y_ /= rhs.y_;
+    return *this;
+  }
+
+  // External operators
+  friend Vec2 operator-(const Vec2& rhs) { return Vec2(rhs) *= -1; }
+
+  friend Vec2 operator*(const float lhs, const Vec2& rhs) {
+    Vec2 ret;
+    ret.x_ = lhs * rhs.x_;
+    ret.y_ = lhs * rhs.y_;
+    return ret;
+  }
+
+  friend Vec2 operator/(const float lhs, const Vec2& rhs) {
+    Vec2 ret;
+    ret.x_ = lhs / rhs.x_;
+    ret.y_ = lhs / rhs.y_;
+    return ret;
+  }
+
+  // Operators with float
+  Vec2 operator*(const float& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ * rhs;
+    ret.y_ = y_ * rhs;
+    return ret;
+  }
+
+  Vec2& operator*=(const float& rhs) {
+    x_ = x_ * rhs;
+    y_ = y_ * rhs;
+    return *this;
+  }
+
+  Vec2 operator/(const float& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ / rhs;
+    ret.y_ = y_ / rhs;
+    return ret;
+  }
+
+  Vec2& operator/=(const float& rhs) {
+    x_ = x_ / rhs;
+    y_ = y_ / rhs;
+    return *this;
+  }
+
+  // Compare
+  bool operator==(const Vec2& rhs) const {
+    if (x_ != rhs.x_ || y_ != rhs.y_) return false;
+    return true;
+  }
+
+  bool operator!=(const Vec2& rhs) const {
+    if (x_ == rhs.x_) return false;
+
+    return true;
+  }
+
+  float Length() const { return sqrtf(x_ * x_ + y_ * y_); }
+
+  Vec2 Normalize() {
+    float len = Length();
+    x_ = x_ / len;
+    y_ = y_ / len;
+    return *this;
+  }
+
+  float Dot(const Vec2& rhs) { return x_ * rhs.x_ + y_ * rhs.y_; }
+
+  bool Validate() {
+    if (isnan(x_) || isnan(y_)) return false;
+    return true;
+  }
+
+  void Value(float& fX, float& fY) {
+    fX = x_;
+    fY = y_;
+  }
+
+  void Dump() { LOGI("Vec2 %f %f", x_, y_); }
+};
+
+/******************************************************************
+ * 3 elements vector class
+ *
+ */
+class Vec3 {
+ private:
+  float x_, y_, z_;
+
+ public:
+  friend class Vec4;
+  friend class Mat4;
+  friend class Quaternion;
+
+  Vec3() { x_ = y_ = z_ = 0.f; }
+
+  Vec3(const float fX, const float fY, const float fZ) {
+    x_ = fX;
+    y_ = fY;
+    z_ = fZ;
+  }
+
+  Vec3(const Vec3& vec) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+    z_ = vec.z_;
+  }
+
+  Vec3(const float* pVec) {
+    x_ = (*pVec++);
+    y_ = (*pVec++);
+    z_ = *pVec;
+  }
+
+  Vec3(const Vec2& vec, float f) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+    z_ = f;
+  }
+
+  Vec3(const Vec4& vec);
+
+  // Operators
+  Vec3 operator*(const Vec3& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ * rhs.x_;
+    ret.y_ = y_ * rhs.y_;
+    ret.z_ = z_ * rhs.z_;
+    return ret;
+  }
+
+  Vec3 operator/(const Vec3& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ / rhs.x_;
+    ret.y_ = y_ / rhs.y_;
+    ret.z_ = z_ / rhs.z_;
+    return ret;
+  }
+
+  Vec3 operator+(const Vec3& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ + rhs.x_;
+    ret.y_ = y_ + rhs.y_;
+    ret.z_ = z_ + rhs.z_;
+    return ret;
+  }
+
+  Vec3 operator-(const Vec3& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ - rhs.x_;
+    ret.y_ = y_ - rhs.y_;
+    ret.z_ = z_ - rhs.z_;
+    return ret;
+  }
+
+  Vec3& operator+=(const Vec3& rhs) {
+    x_ += rhs.x_;
+    y_ += rhs.y_;
+    z_ += rhs.z_;
+    return *this;
+  }
+
+  Vec3& operator-=(const Vec3& rhs) {
+    x_ -= rhs.x_;
+    y_ -= rhs.y_;
+    z_ -= rhs.z_;
+    return *this;
+  }
+
+  Vec3& operator*=(const Vec3& rhs) {
+    x_ *= rhs.x_;
+    y_ *= rhs.y_;
+    z_ *= rhs.z_;
+    return *this;
+  }
+
+  Vec3& operator/=(const Vec3& rhs) {
+    x_ /= rhs.x_;
+    y_ /= rhs.y_;
+    z_ /= rhs.z_;
+    return *this;
+  }
+
+  // External operators
+  friend Vec3 operator-(const Vec3& rhs) { return Vec3(rhs) *= -1; }
+
+  friend Vec3 operator*(const float lhs, const Vec3& rhs) {
+    Vec3 ret;
+    ret.x_ = lhs * rhs.x_;
+    ret.y_ = lhs * rhs.y_;
+    ret.z_ = lhs * rhs.z_;
+    return ret;
+  }
+
+  friend Vec3 operator/(const float lhs, const Vec3& rhs) {
+    Vec3 ret;
+    ret.x_ = lhs / rhs.x_;
+    ret.y_ = lhs / rhs.y_;
+    ret.z_ = lhs / rhs.z_;
+    return ret;
+  }
+
+  // Operators with float
+  Vec3 operator*(const float& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ * rhs;
+    ret.y_ = y_ * rhs;
+    ret.z_ = z_ * rhs;
+    return ret;
+  }
+
+  Vec3& operator*=(const float& rhs) {
+    x_ = x_ * rhs;
+    y_ = y_ * rhs;
+    z_ = z_ * rhs;
+    return *this;
+  }
+
+  Vec3 operator/(const float& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ / rhs;
+    ret.y_ = y_ / rhs;
+    ret.z_ = z_ / rhs;
+    return ret;
+  }
+
+  Vec3& operator/=(const float& rhs) {
+    x_ = x_ / rhs;
+    y_ = y_ / rhs;
+    z_ = z_ / rhs;
+    return *this;
+  }
+
+  // Compare
+  bool operator==(const Vec3& rhs) const {
+    if (x_ != rhs.x_ || y_ != rhs.y_ || z_ != rhs.z_) return false;
+    return true;
+  }
+
+  bool operator!=(const Vec3& rhs) const {
+    if (x_ == rhs.x_) return false;
+
+    return true;
+  }
+
+  float Length() const { return sqrtf(x_ * x_ + y_ * y_ + z_ * z_); }
+
+  Vec3 Normalize() {
+    float len = Length();
+    x_ = x_ / len;
+    y_ = y_ / len;
+    z_ = z_ / len;
+    return *this;
+  }
+
+  float Dot(const Vec3& rhs) { return x_ * rhs.x_ + y_ * rhs.y_ + z_ * rhs.z_; }
+
+  Vec3 Cross(const Vec3& rhs) {
+    Vec3 ret;
+    ret.x_ = y_ * rhs.z_ - z_ * rhs.y_;
+    ret.y_ = z_ * rhs.x_ - x_ * rhs.z_;
+    ret.z_ = x_ * rhs.y_ - y_ * rhs.x_;
+    return ret;
+  }
+
+  bool Validate() {
+    if (isnan(x_) || isnan(y_) || isnan(z_)) return false;
+    return true;
+  }
+
+  void Value(float& fX, float& fY, float& fZ) {
+    fX = x_;
+    fY = y_;
+    fZ = z_;
+  }
+
+  void Dump() { LOGI("Vec3 %f %f %f", x_, y_, z_); }
+};
+
+/******************************************************************
+ * 4 elements vector class
+ *
+ */
+class Vec4 {
+ private:
+  float x_, y_, z_, w_;
+
+ public:
+  friend class Vec3;
+  friend class Mat4;
+  friend class Quaternion;
+
+  Vec4() { x_ = y_ = z_ = w_ = 0.f; }
+
+  Vec4(const float fX, const float fY, const float fZ, const float fW) {
+    x_ = fX;
+    y_ = fY;
+    z_ = fZ;
+    w_ = fW;
+  }
+
+  Vec4(const Vec4& vec) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+    z_ = vec.z_;
+    w_ = vec.w_;
+  }
+
+  Vec4(const Vec3& vec, const float fW) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+    z_ = vec.z_;
+    w_ = fW;
+  }
+
+  Vec4(const float* pVec) {
+    x_ = (*pVec++);
+    y_ = (*pVec++);
+    z_ = *pVec;
+    w_ = *pVec;
+  }
+
+  // Operators
+  Vec4 operator*(const Vec4& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ * rhs.x_;
+    ret.y_ = y_ * rhs.y_;
+    ret.z_ = z_ * rhs.z_;
+    ret.w_ = z_ * rhs.w_;
+    return ret;
+  }
+
+  Vec4 operator/(const Vec4& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ / rhs.x_;
+    ret.y_ = y_ / rhs.y_;
+    ret.z_ = z_ / rhs.z_;
+    ret.w_ = z_ / rhs.w_;
+    return ret;
+  }
+
+  Vec4 operator+(const Vec4& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ + rhs.x_;
+    ret.y_ = y_ + rhs.y_;
+    ret.z_ = z_ + rhs.z_;
+    ret.w_ = z_ + rhs.w_;
+    return ret;
+  }
+
+  Vec4 operator-(const Vec4& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ - rhs.x_;
+    ret.y_ = y_ - rhs.y_;
+    ret.z_ = z_ - rhs.z_;
+    ret.w_ = z_ - rhs.w_;
+    return ret;
+  }
+
+  Vec4& operator+=(const Vec4& rhs) {
+    x_ += rhs.x_;
+    y_ += rhs.y_;
+    z_ += rhs.z_;
+    w_ += rhs.w_;
+    return *this;
+  }
+
+  Vec4& operator-=(const Vec4& rhs) {
+    x_ -= rhs.x_;
+    y_ -= rhs.y_;
+    z_ -= rhs.z_;
+    w_ -= rhs.w_;
+    return *this;
+  }
+
+  Vec4& operator*=(const Vec4& rhs) {
+    x_ *= rhs.x_;
+    y_ *= rhs.y_;
+    z_ *= rhs.z_;
+    w_ *= rhs.w_;
+    return *this;
+  }
+
+  Vec4& operator/=(const Vec4& rhs) {
+    x_ /= rhs.x_;
+    y_ /= rhs.y_;
+    z_ /= rhs.z_;
+    w_ /= rhs.w_;
+    return *this;
+  }
+
+  // External operators
+  friend Vec4 operator-(const Vec4& rhs) { return Vec4(rhs) *= -1; }
+
+  friend Vec4 operator*(const float lhs, const Vec4& rhs) {
+    Vec4 ret;
+    ret.x_ = lhs * rhs.x_;
+    ret.y_ = lhs * rhs.y_;
+    ret.z_ = lhs * rhs.z_;
+    ret.w_ = lhs * rhs.w_;
+    return ret;
+  }
+
+  friend Vec4 operator/(const float lhs, const Vec4& rhs) {
+    Vec4 ret;
+    ret.x_ = lhs / rhs.x_;
+    ret.y_ = lhs / rhs.y_;
+    ret.z_ = lhs / rhs.z_;
+    ret.w_ = lhs / rhs.w_;
+    return ret;
+  }
+
+  // Operators with float
+  Vec4 operator*(const float& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ * rhs;
+    ret.y_ = y_ * rhs;
+    ret.z_ = z_ * rhs;
+    ret.w_ = w_ * rhs;
+    return ret;
+  }
+
+  Vec4& operator*=(const float& rhs) {
+    x_ = x_ * rhs;
+    y_ = y_ * rhs;
+    z_ = z_ * rhs;
+    w_ = w_ * rhs;
+    return *this;
+  }
+
+  Vec4 operator/(const float& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ / rhs;
+    ret.y_ = y_ / rhs;
+    ret.z_ = z_ / rhs;
+    ret.w_ = w_ / rhs;
+    return ret;
+  }
+
+  Vec4& operator/=(const float& rhs) {
+    x_ = x_ / rhs;
+    y_ = y_ / rhs;
+    z_ = z_ / rhs;
+    w_ = w_ / rhs;
+    return *this;
+  }
+
+  // Compare
+  bool operator==(const Vec4& rhs) const {
+    if (x_ != rhs.x_ || y_ != rhs.y_ || z_ != rhs.z_ || w_ != rhs.w_)
+      return false;
+    return true;
+  }
+
+  bool operator!=(const Vec4& rhs) const {
+    if (x_ == rhs.x_) return false;
+
+    return true;
+  }
+
+  Vec4 operator*(const Mat4& rhs) const;
+
+  float Length() const { return sqrtf(x_ * x_ + y_ * y_ + z_ * z_ + w_ * w_); }
+
+  Vec4 Normalize() {
+    float len = Length();
+    x_ = x_ / len;
+    y_ = y_ / len;
+    z_ = z_ / len;
+    w_ = w_ / len;
+    return *this;
+  }
+
+  float Dot(const Vec3& rhs) { return x_ * rhs.x_ + y_ * rhs.y_ + z_ * rhs.z_; }
+
+  Vec3 Cross(const Vec3& rhs) {
+    Vec3 ret;
+    ret.x_ = y_ * rhs.z_ - z_ * rhs.y_;
+    ret.y_ = z_ * rhs.x_ - x_ * rhs.z_;
+    ret.z_ = x_ * rhs.y_ - y_ * rhs.x_;
+    return ret;
+  }
+
+  bool Validate() {
+    if (isnan(x_) || isnan(y_) || isnan(z_) || isnan(w_)) return false;
+    return true;
+  }
+
+  void Value(float& fX, float& fY, float& fZ, float& fW) {
+    fX = x_;
+    fY = y_;
+    fZ = z_;
+    fW = w_;
+  }
+};
+
+/******************************************************************
+ * 4x4 matrix
+ *
+ */
+class Mat4 {
+ private:
+  float f_[16];
+
+ public:
+  friend class Vec3;
+  friend class Vec4;
+  friend class Quaternion;
+
+  Mat4();
+  Mat4(const float*);
+
+  Mat4 operator*(const Mat4& rhs) const;
+  Vec4 operator*(const Vec4& rhs) const;
+
+  Mat4 operator+(const Mat4& rhs) const {
+    Mat4 ret;
+    for (int32_t i = 0; i < 16; ++i) {
+      ret.f_[i] = f_[i] + rhs.f_[i];
+    }
+    return ret;
+  }
+
+  Mat4 operator-(const Mat4& rhs) const {
+    Mat4 ret;
+    for (int32_t i = 0; i < 16; ++i) {
+      ret.f_[i] = f_[i] - rhs.f_[i];
+    }
+    return ret;
+  }
+
+  Mat4& operator+=(const Mat4& rhs) {
+    for (int32_t i = 0; i < 16; ++i) {
+      f_[i] += rhs.f_[i];
+    }
+    return *this;
+  }
+
+  Mat4& operator-=(const Mat4& rhs) {
+    for (int32_t i = 0; i < 16; ++i) {
+      f_[i] -= rhs.f_[i];
+    }
+    return *this;
+  }
+
+  Mat4& operator*=(const Mat4& rhs) {
+    Mat4 ret;
+    ret.f_[0] = f_[0] * rhs.f_[0] + f_[4] * rhs.f_[1] + f_[8] * rhs.f_[2] +
+                f_[12] * rhs.f_[3];
+    ret.f_[1] = f_[1] * rhs.f_[0] + f_[5] * rhs.f_[1] + f_[9] * rhs.f_[2] +
+                f_[13] * rhs.f_[3];
+    ret.f_[2] = f_[2] * rhs.f_[0] + f_[6] * rhs.f_[1] + f_[10] * rhs.f_[2] +
+                f_[14] * rhs.f_[3];
+    ret.f_[3] = f_[3] * rhs.f_[0] + f_[7] * rhs.f_[1] + f_[11] * rhs.f_[2] +
+                f_[15] * rhs.f_[3];
+
+    ret.f_[4] = f_[0] * rhs.f_[4] + f_[4] * rhs.f_[5] + f_[8] * rhs.f_[6] +
+                f_[12] * rhs.f_[7];
+    ret.f_[5] = f_[1] * rhs.f_[4] + f_[5] * rhs.f_[5] + f_[9] * rhs.f_[6] +
+                f_[13] * rhs.f_[7];
+    ret.f_[6] = f_[2] * rhs.f_[4] + f_[6] * rhs.f_[5] + f_[10] * rhs.f_[6] +
+                f_[14] * rhs.f_[7];
+    ret.f_[7] = f_[3] * rhs.f_[4] + f_[7] * rhs.f_[5] + f_[11] * rhs.f_[6] +
+                f_[15] * rhs.f_[7];
+
+    ret.f_[8] = f_[0] * rhs.f_[8] + f_[4] * rhs.f_[9] + f_[8] * rhs.f_[10] +
+                f_[12] * rhs.f_[11];
+    ret.f_[9] = f_[1] * rhs.f_[8] + f_[5] * rhs.f_[9] + f_[9] * rhs.f_[10] +
+                f_[13] * rhs.f_[11];
+    ret.f_[10] = f_[2] * rhs.f_[8] + f_[6] * rhs.f_[9] + f_[10] * rhs.f_[10] +
+                 f_[14] * rhs.f_[11];
+    ret.f_[11] = f_[3] * rhs.f_[8] + f_[7] * rhs.f_[9] + f_[11] * rhs.f_[10] +
+                 f_[15] * rhs.f_[11];
+
+    ret.f_[12] = f_[0] * rhs.f_[12] + f_[4] * rhs.f_[13] + f_[8] * rhs.f_[14] +
+                 f_[12] * rhs.f_[15];
+    ret.f_[13] = f_[1] * rhs.f_[12] + f_[5] * rhs.f_[13] + f_[9] * rhs.f_[14] +
+                 f_[13] * rhs.f_[15];
+    ret.f_[14] = f_[2] * rhs.f_[12] + f_[6] * rhs.f_[13] + f_[10] * rhs.f_[14] +
+                 f_[14] * rhs.f_[15];
+    ret.f_[15] = f_[3] * rhs.f_[12] + f_[7] * rhs.f_[13] + f_[11] * rhs.f_[14] +
+                 f_[15] * rhs.f_[15];
+
+    *this = ret;
+    return *this;
+  }
+
+  Mat4 operator*(const float rhs) {
+    Mat4 ret;
+    for (int32_t i = 0; i < 16; ++i) {
+      ret.f_[i] = f_[i] * rhs;
+    }
+    return ret;
+  }
+
+  Mat4& operator*=(const float rhs) {
+    for (int32_t i = 0; i < 16; ++i) {
+      f_[i] *= rhs;
+    }
+    return *this;
+  }
+
+  Mat4& operator=(const Mat4& rhs) {
+    for (int32_t i = 0; i < 16; ++i) {
+      f_[i] = rhs.f_[i];
+    }
+    return *this;
+  }
+
+  Mat4 Inverse();
+
+  Mat4 Transpose() {
+    Mat4 ret;
+    ret.f_[0] = f_[0];
+    ret.f_[1] = f_[4];
+    ret.f_[2] = f_[8];
+    ret.f_[3] = f_[12];
+    ret.f_[4] = f_[1];
+    ret.f_[5] = f_[5];
+    ret.f_[6] = f_[9];
+    ret.f_[7] = f_[13];
+    ret.f_[8] = f_[2];
+    ret.f_[9] = f_[6];
+    ret.f_[10] = f_[10];
+    ret.f_[11] = f_[14];
+    ret.f_[12] = f_[3];
+    ret.f_[13] = f_[7];
+    ret.f_[14] = f_[11];
+    ret.f_[15] = f_[15];
+    *this = ret;
+    return *this;
+  }
+
+  Mat4& PostTranslate(float tx, float ty, float tz) {
+    f_[12] += (tx * f_[0]) + (ty * f_[4]) + (tz * f_[8]);
+    f_[13] += (tx * f_[1]) + (ty * f_[5]) + (tz * f_[9]);
+    f_[14] += (tx * f_[2]) + (ty * f_[6]) + (tz * f_[10]);
+    f_[15] += (tx * f_[3]) + (ty * f_[7]) + (tz * f_[11]);
+    return *this;
+  }
+
+  float* Ptr() { return f_; }
+
+  //--------------------------------------------------------------------------------
+  // Misc
+  //--------------------------------------------------------------------------------
+  static Mat4 Perspective(float width, float height, float nearPlane,
+                          float farPlane);
+
+  static Mat4 LookAt(const Vec3& vEye, const Vec3& vAt, const Vec3& vUp);
+
+  static Mat4 Translation(const float fX, const float fY, const float fZ);
+  static Mat4 Translation(const Vec3 vec);
+
+  static Mat4 RotationX(const float angle);
+
+  static Mat4 RotationY(const float angle);
+
+  static Mat4 RotationZ(const float angle);
+
+  static Mat4 Identity() {
+    Mat4 ret;
+    ret.f_[0] = 1.f;
+    ret.f_[1] = 0;
+    ret.f_[2] = 0;
+    ret.f_[3] = 0;
+    ret.f_[4] = 0;
+    ret.f_[5] = 1.f;
+    ret.f_[6] = 0;
+    ret.f_[7] = 0;
+    ret.f_[8] = 0;
+    ret.f_[9] = 0;
+    ret.f_[10] = 1.f;
+    ret.f_[11] = 0;
+    ret.f_[12] = 0;
+    ret.f_[13] = 0;
+    ret.f_[14] = 0;
+    ret.f_[15] = 1.f;
+    return ret;
+  }
+
+  void Dump() {
+    LOGI("%f %f %f %f", f_[0], f_[1], f_[2], f_[3]);
+    LOGI("%f %f %f %f", f_[4], f_[5], f_[6], f_[7]);
+    LOGI("%f %f %f %f", f_[8], f_[9], f_[10], f_[11]);
+    LOGI("%f %f %f %f", f_[12], f_[13], f_[14], f_[15]);
+  }
+};
+
+/******************************************************************
+ * Quaternion class
+ *
+ */
+class Quaternion {
+ private:
+  float x_, y_, z_, w_;
+
+ public:
+  friend class Vec3;
+  friend class Vec4;
+  friend class Mat4;
+
+  Quaternion() {
+    x_ = 0.f;
+    y_ = 0.f;
+    z_ = 0.f;
+    w_ = 1.f;
+  }
+
+  Quaternion(const float fX, const float fY, const float fZ, const float fW) {
+    x_ = fX;
+    y_ = fY;
+    z_ = fZ;
+    w_ = fW;
+  }
+
+  Quaternion(const Vec3 vec, const float fW) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+    z_ = vec.z_;
+    w_ = fW;
+  }
+
+  Quaternion(const float* p) {
+    x_ = *p++;
+    y_ = *p++;
+    z_ = *p++;
+    w_ = *p++;
+  }
+
+  Quaternion operator*(const Quaternion rhs) {
+    Quaternion ret;
+    ret.x_ = x_ * rhs.w_ + y_ * rhs.z_ - z_ * rhs.y_ + w_ * rhs.x_;
+    ret.y_ = -x_ * rhs.z_ + y_ * rhs.w_ + z_ * rhs.x_ + w_ * rhs.y_;
+    ret.z_ = x_ * rhs.y_ - y_ * rhs.x_ + z_ * rhs.w_ + w_ * rhs.z_;
+    ret.w_ = -x_ * rhs.x_ - y_ * rhs.y_ - z_ * rhs.z_ + w_ * rhs.w_;
+    return ret;
+  }
+
+  Quaternion& operator*=(const Quaternion rhs) {
+    Quaternion ret;
+    ret.x_ = x_ * rhs.w_ + y_ * rhs.z_ - z_ * rhs.y_ + w_ * rhs.x_;
+    ret.y_ = -x_ * rhs.z_ + y_ * rhs.w_ + z_ * rhs.x_ + w_ * rhs.y_;
+    ret.z_ = x_ * rhs.y_ - y_ * rhs.x_ + z_ * rhs.w_ + w_ * rhs.z_;
+    ret.w_ = -x_ * rhs.x_ - y_ * rhs.y_ - z_ * rhs.z_ + w_ * rhs.w_;
+    *this = ret;
+    return *this;
+  }
+
+  Quaternion Conjugate() {
+    x_ = -x_;
+    y_ = -y_;
+    z_ = -z_;
+    return *this;
+  }
+
+  // Non destuctive version
+  Quaternion Conjugated() {
+    Quaternion ret;
+    ret.x_ = -x_;
+    ret.y_ = -y_;
+    ret.z_ = -z_;
+    ret.w_ = w_;
+    return ret;
+  }
+
+  void ToMatrix(Mat4& mat) {
+    float x2 = x_ * x_ * 2.0f;
+    float y2 = y_ * y_ * 2.0f;
+    float z2 = z_ * z_ * 2.0f;
+    float xy = x_ * y_ * 2.0f;
+    float yz = y_ * z_ * 2.0f;
+    float zx = z_ * x_ * 2.0f;
+    float xw = x_ * w_ * 2.0f;
+    float yw = y_ * w_ * 2.0f;
+    float zw = z_ * w_ * 2.0f;
+
+    mat.f_[0] = 1.0f - y2 - z2;
+    mat.f_[1] = xy + zw;
+    mat.f_[2] = zx - yw;
+    mat.f_[4] = xy - zw;
+    mat.f_[5] = 1.0f - z2 - x2;
+    mat.f_[6] = yz + xw;
+    mat.f_[8] = zx + yw;
+    mat.f_[9] = yz - xw;
+    mat.f_[10] = 1.0f - x2 - y2;
+
+    mat.f_[3] = mat.f_[7] = mat.f_[11] = mat.f_[12] = mat.f_[13] = mat.f_[14] =
+        0.0f;
+    mat.f_[15] = 1.0f;
+  }
+
+  void ToMatrixPreserveTranslate(Mat4& mat) {
+    float x2 = x_ * x_ * 2.0f;
+    float y2 = y_ * y_ * 2.0f;
+    float z2 = z_ * z_ * 2.0f;
+    float xy = x_ * y_ * 2.0f;
+    float yz = y_ * z_ * 2.0f;
+    float zx = z_ * x_ * 2.0f;
+    float xw = x_ * w_ * 2.0f;
+    float yw = y_ * w_ * 2.0f;
+    float zw = z_ * w_ * 2.0f;
+
+    mat.f_[0] = 1.0f - y2 - z2;
+    mat.f_[1] = xy + zw;
+    mat.f_[2] = zx - yw;
+    mat.f_[4] = xy - zw;
+    mat.f_[5] = 1.0f - z2 - x2;
+    mat.f_[6] = yz + xw;
+    mat.f_[8] = zx + yw;
+    mat.f_[9] = yz - xw;
+    mat.f_[10] = 1.0f - x2 - y2;
+
+    mat.f_[3] = mat.f_[7] = mat.f_[11] = 0.0f;
+    mat.f_[15] = 1.0f;
+  }
+
+  static Quaternion RotationAxis(const Vec3 axis, const float angle) {
+    Quaternion ret;
+    float s = sinf(angle / 2);
+    ret.x_ = s * axis.x_;
+    ret.y_ = s * axis.y_;
+    ret.z_ = s * axis.z_;
+    ret.w_ = cosf(angle / 2);
+    return ret;
+  }
+
+  void Value(float& fX, float& fY, float& fZ, float& fW) {
+    fX = x_;
+    fY = y_;
+    fZ = z_;
+    fW = w_;
+  }
+};
+
+}  // namespace ndk_helper
+#endif /* VECMATH_H_ */

MoreTeapots/app/src/main/res/layout/widgets.xml

@@ -9,8 +9,8 @@
         android:id="@+id/textViewFPS"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:gravity="right"
-        android:text="0.0 FPS"
+        android:gravity="end"
+        android:text="@string/fps"
         android:textAppearance="?android:attr/textAppearanceMedium"
         android:textColor="@android:color/white" />
 

MoreTeapots/app/src/main/res/values/strings.xml

@@ -1,5 +1,6 @@
 <resources>
 
     <string name="app_name">More Teapots</string>
+    <string name="fps">0.0 FPS</string>
 
 </resources>

MoreTeapots/build.gradle

@@ -0,0 +1,15 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+buildscript {
+    repositories {
+       jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle-experimental:0.7.0-beta1'
+    }
+}
+
+allprojects {
+    repositories {
+        jcenter()
+    }
+}

MoreTeapots/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Wed Apr 10 15:27:10 PDT 2013
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip

MoreTeapots/gradlew

@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

MoreTeapots/gradlew.bat

@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

MoreTeapots/jni/Android.mk

@@ -1,19 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE    := MoreTeapotsNativeActivity
-LOCAL_SRC_FILES := MoreTeapotsNativeActivity.cpp \
-MoreTeapotsRenderer.cpp \
-
-LOCAL_C_INCLUDES :=
-LOCAL_CFLAGS :=
-
-LOCAL_LDLIBS    := -llog -landroid -lEGL -lGLESv2
-LOCAL_STATIC_LIBRARIES := cpufeatures android_native_app_glue ndk_helper
-
-include $(BUILD_SHARED_LIBRARY)
-
-$(call import-module,android/ndk_helper)
-$(call import-module,android/native_app_glue)
-$(call import-module,android/cpufeatures)

MoreTeapots/jni/Application.mk

@@ -1,4 +0,0 @@
-APP_PLATFORM := android-9
-APP_ABI := all
-
-APP_STL := stlport_static

MoreTeapots/jni/MoreTeapotsNativeActivity.cpp

@@ -1,500 +0,0 @@
-/*
- * Copyright 2013 The Android Open Source Project
- *
- * 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 files
-//--------------------------------------------------------------------------------
-#include <jni.h>
-#include <errno.h>
-
-#include <vector>
-#include <EGL/egl.h>
-#include <GLES/gl.h>
-
-#include <android/sensor.h>
-#include <android/log.h>
-#include <android_native_app_glue.h>
-#include <android/native_window_jni.h>
-#include <cpu-features.h>
-
-#include "MoreTeapotsRenderer.h"
-
-//-------------------------------------------------------------------------
-//Preprocessor
-//-------------------------------------------------------------------------
-#define HELPER_CLASS_NAME "com/sample/helper/NDKHelper" //Class name of helper function
-//-------------------------------------------------------------------------
-//Constants
-//-------------------------------------------------------------------------
-const int32_t NUM_TEAPOTS_X = 8;
-const int32_t NUM_TEAPOTS_Y = 8;
-const int32_t NUM_TEAPOTS_Z = 8;
-
-//-------------------------------------------------------------------------
-//Shared state for our app.
-//-------------------------------------------------------------------------
-struct android_app;
-class Engine
-{
-    MoreTeapotsRenderer renderer_;
-
-    ndk_helper::GLContext* gl_context_;
-
-    bool initialized_resources_;
-    bool has_focus_;
-
-    ndk_helper::DoubletapDetector doubletap_detector_;
-    ndk_helper::PinchDetector pinch_detector_;
-    ndk_helper::DragDetector drag_detector_;
-    ndk_helper::PerfMonitor monitor_;
-
-    ndk_helper::TapCamera tap_camera_;
-
-    android_app* app_;
-
-    ASensorManager* sensor_manager_;
-    const ASensor* accelerometer_sensor_;
-    ASensorEventQueue* sensor_event_queue_;
-
-    void UpdateFPS( float fps );
-    void ShowUI();
-    void TransformPosition( ndk_helper::Vec2& vec );
-
-public:
-    static void HandleCmd( struct android_app* app,
-            int32_t cmd );
-    static int32_t HandleInput( android_app* app,
-            AInputEvent* event );
-
-    Engine();
-    ~Engine();
-    void SetState( android_app* state );
-    int InitDisplay();
-    void LoadResources();
-    void UnloadResources();
-    void DrawFrame();
-    void TermDisplay();
-    void TrimMemory();
-    bool IsReady();
-
-    void UpdatePosition( AInputEvent* event,
-            int32_t index,
-            float& x,
-            float& y );
-
-    void InitSensors();
-    void ProcessSensors( int32_t id );
-    void SuspendSensors();
-    void ResumeSensors();
-};
-
-//-------------------------------------------------------------------------
-//Ctor
-//-------------------------------------------------------------------------
-Engine::Engine() :
-                initialized_resources_( false ),
-                has_focus_( false ),
-                app_( NULL ),
-                sensor_manager_( NULL ),
-                accelerometer_sensor_( NULL ),
-                sensor_event_queue_( NULL )
-{
-    gl_context_ = ndk_helper::GLContext::GetInstance();
-}
-
-//-------------------------------------------------------------------------
-//Dtor
-//-------------------------------------------------------------------------
-Engine::~Engine()
-{
-}
-
-/**
- * Load resources
- */
-void Engine::LoadResources()
-{
-    renderer_.Init( NUM_TEAPOTS_X, NUM_TEAPOTS_Y, NUM_TEAPOTS_Z );
-    renderer_.Bind( &tap_camera_ );
-}
-
-/**
- * Unload resources
- */
-void Engine::UnloadResources()
-{
-    renderer_.Unload();
-}
-
-/**
- * Initialize an EGL context for the current display.
- */
-int Engine::InitDisplay()
-{
-    if( !initialized_resources_ )
-    {
-        gl_context_->Init( app_->window );
-        LoadResources();
-        initialized_resources_ = true;
-    }
-    else
-    {
-        // initialize OpenGL ES and EGL
-        if( EGL_SUCCESS != gl_context_->Resume( app_->window ) )
-        {
-            UnloadResources();
-            LoadResources();
-        }
-    }
-
-    ShowUI();
-
-    // Initialize GL state.
-    glEnable( GL_CULL_FACE );
-    glEnable( GL_DEPTH_TEST );
-    glDepthFunc( GL_LEQUAL );
-
-    //Note that screen size might have been changed
-    glViewport( 0, 0, gl_context_->GetScreenWidth(), gl_context_->GetScreenHeight() );
-    renderer_.UpdateViewport();
-
-    tap_camera_.SetFlip( 1.f, -1.f, -1.f );
-    tap_camera_.SetPinchTransformFactor( 10.f, 10.f, 8.f );
-
-    return 0;
-}
-
-/**
- * Just the current frame in the display.
- */
-void Engine::DrawFrame()
-{
-    float fps;
-    if( monitor_.Update( fps ) )
-    {
-        UpdateFPS( fps );
-    }
-    double dTime = monitor_.GetCurrentTime();
-    renderer_.Update( dTime );
-
-    // Just fill the screen with a color.
-    glClearColor( 0.5f, 0.5f, 0.5f, 1.f );
-    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
-    renderer_.Render();
-
-    // Swap
-    if( EGL_SUCCESS != gl_context_->Swap() )
-    {
-        UnloadResources();
-        LoadResources();
-    }
-}
-
-/**
- * Tear down the EGL context currently associated with the display.
- */
-void Engine::TermDisplay()
-{
-    gl_context_->Suspend();
-
-}
-
-void Engine::TrimMemory()
-{
-    LOGI( "Trimming memory" );
-    gl_context_->Invalidate();
-}
-/**
- * Process the next input event.
- */
-int32_t Engine::HandleInput( android_app* app,
-        AInputEvent* event )
-{
-    Engine* eng = (Engine*) app->userData;
-    if( AInputEvent_getType( event ) == AINPUT_EVENT_TYPE_MOTION )
-    {
-        ndk_helper::GESTURE_STATE doubleTapState = eng->doubletap_detector_.Detect( event );
-        ndk_helper::GESTURE_STATE dragState = eng->drag_detector_.Detect( event );
-        ndk_helper::GESTURE_STATE pinchState = eng->pinch_detector_.Detect( event );
-
-        //Double tap detector has a priority over other detectors
-        if( doubleTapState == ndk_helper::GESTURE_STATE_ACTION )
-        {
-            //Detect double tap
-            eng->tap_camera_.Reset( true );
-        }
-        else
-        {
-            //Handle drag state
-            if( dragState & ndk_helper::GESTURE_STATE_START )
-            {
-                //Otherwise, start dragging
-                ndk_helper::Vec2 v;
-                eng->drag_detector_.GetPointer( v );
-                eng->TransformPosition( v );
-                eng->tap_camera_.BeginDrag( v );
-            }
-            else if( dragState & ndk_helper::GESTURE_STATE_MOVE )
-            {
-                ndk_helper::Vec2 v;
-                eng->drag_detector_.GetPointer( v );
-                eng->TransformPosition( v );
-                eng->tap_camera_.Drag( v );
-            }
-            else if( dragState & ndk_helper::GESTURE_STATE_END )
-            {
-                eng->tap_camera_.EndDrag();
-            }
-
-            //Handle pinch state
-            if( pinchState & ndk_helper::GESTURE_STATE_START )
-            {
-                //Start new pinch
-                ndk_helper::Vec2 v1;
-                ndk_helper::Vec2 v2;
-                eng->pinch_detector_.GetPointers( v1, v2 );
-                eng->TransformPosition( v1 );
-                eng->TransformPosition( v2 );
-                eng->tap_camera_.BeginPinch( v1, v2 );
-            }
-            else if( pinchState & ndk_helper::GESTURE_STATE_MOVE )
-            {
-                //Multi touch
-                //Start new pinch
-                ndk_helper::Vec2 v1;
-                ndk_helper::Vec2 v2;
-                eng->pinch_detector_.GetPointers( v1, v2 );
-                eng->TransformPosition( v1 );
-                eng->TransformPosition( v2 );
-                eng->tap_camera_.Pinch( v1, v2 );
-            }
-        }
-        return 1;
-    }
-    return 0;
-}
-
-/**
- * Process the next main command.
- */
-void Engine::HandleCmd( struct android_app* app,
-        int32_t cmd )
-{
-    Engine* eng = (Engine*) app->userData;
-    switch( cmd )
-    {
-    case APP_CMD_SAVE_STATE:
-        break;
-    case APP_CMD_INIT_WINDOW:
-        // The window is being shown, get it ready.
-        if( app->window != NULL )
-        {
-            eng->InitDisplay();
-            eng->DrawFrame();
-        }
-        break;
-    case APP_CMD_TERM_WINDOW:
-        // The window is being hidden or closed, clean it up.
-        eng->TermDisplay();
-        eng->has_focus_ = false;
-        break;
-    case APP_CMD_STOP:
-        break;
-    case APP_CMD_GAINED_FOCUS:
-        eng->ResumeSensors();
-        //Start animation
-        eng->has_focus_ = true;
-        break;
-    case APP_CMD_LOST_FOCUS:
-        eng->SuspendSensors();
-        // Also stop animating.
-        eng->has_focus_ = false;
-        eng->DrawFrame();
-        break;
-    case APP_CMD_LOW_MEMORY:
-        //Free up GL resources
-        eng->TrimMemory();
-        break;
-    }
-}
-
-//-------------------------------------------------------------------------
-//Sensor handlers
-//-------------------------------------------------------------------------
-void Engine::InitSensors()
-{
-    sensor_manager_ = ASensorManager_getInstance();
-    accelerometer_sensor_ = ASensorManager_getDefaultSensor( sensor_manager_,
-            ASENSOR_TYPE_ACCELEROMETER );
-    sensor_event_queue_ = ASensorManager_createEventQueue( sensor_manager_, app_->looper,
-            LOOPER_ID_USER, NULL, NULL );
-}
-
-void Engine::ProcessSensors( int32_t id )
-{
-    // If a sensor has data, process it now.
-    if( id == LOOPER_ID_USER )
-    {
-        if( accelerometer_sensor_ != NULL )
-        {
-            ASensorEvent event;
-            while( ASensorEventQueue_getEvents( sensor_event_queue_, &event, 1 ) > 0 )
-            {
-            }
-        }
-    }
-}
-
-void Engine::ResumeSensors()
-{
-    // When our app gains focus, we start monitoring the accelerometer.
-    if( accelerometer_sensor_ != NULL )
-    {
-        ASensorEventQueue_enableSensor( sensor_event_queue_, accelerometer_sensor_ );
-        // We'd like to get 60 events per second (in us).
-        ASensorEventQueue_setEventRate( sensor_event_queue_, accelerometer_sensor_,
-                (1000L / 60) * 1000 );
-    }
-}
-
-void Engine::SuspendSensors()
-{
-    // When our app loses focus, we stop monitoring the accelerometer.
-    // This is to avoid consuming battery while not being used.
-    if( accelerometer_sensor_ != NULL )
-    {
-        ASensorEventQueue_disableSensor( sensor_event_queue_, accelerometer_sensor_ );
-    }
-}
-
-//-------------------------------------------------------------------------
-//Misc
-//-------------------------------------------------------------------------
-void Engine::SetState( android_app* state )
-{
-    app_ = state;
-    doubletap_detector_.SetConfiguration( app_->config );
-    drag_detector_.SetConfiguration( app_->config );
-    pinch_detector_.SetConfiguration( app_->config );
-}
-
-bool Engine::IsReady()
-{
-    if( has_focus_ )
-        return true;
-
-    return false;
-}
-
-void Engine::TransformPosition( ndk_helper::Vec2& vec )
-{
-    vec = ndk_helper::Vec2( 2.0f, 2.0f ) * vec
-            / ndk_helper::Vec2( gl_context_->GetScreenWidth(), gl_context_->GetScreenHeight() )
-            - ndk_helper::Vec2( 1.f, 1.f );
-}
-
-void Engine::ShowUI()
-{
-    JNIEnv *jni;
-    app_->activity->vm->AttachCurrentThread( &jni, NULL );
-
-    //Default class retrieval
-    jclass clazz = jni->GetObjectClass( app_->activity->clazz );
-    jmethodID methodID = jni->GetMethodID( clazz, "showUI", "()V" );
-    jni->CallVoidMethod( app_->activity->clazz, methodID );
-
-    app_->activity->vm->DetachCurrentThread();
-    return;
-}
-
-void Engine::UpdateFPS( float fps )
-{
-    JNIEnv *jni;
-    app_->activity->vm->AttachCurrentThread( &jni, NULL );
-
-    //Default class retrieval
-    jclass clazz = jni->GetObjectClass( app_->activity->clazz );
-    jmethodID methodID = jni->GetMethodID( clazz, "updateFPS", "(F)V" );
-    jni->CallVoidMethod( app_->activity->clazz, methodID, fps );
-
-    app_->activity->vm->DetachCurrentThread();
-    return;
-}
-
-Engine g_engine;
-
-/**
- * This is the main entry point of a native application that is using
- * android_native_app_glue.  It runs in its own thread, with its own
- * event loop for receiving input events and doing other things.
- */
-void android_main( android_app* state )
-{
-    app_dummy();
-
-    g_engine.SetState( state );
-
-    //Init helper functions
-    ndk_helper::JNIHelper::GetInstance()->Init( state->activity, HELPER_CLASS_NAME );
-
-    state->userData = &g_engine;
-    state->onAppCmd = Engine::HandleCmd;
-    state->onInputEvent = Engine::HandleInput;
-
-#ifdef USE_NDK_PROFILER
-    monstartup("libMoreTeapotsNativeActivity.so");
-#endif
-
-    // Prepare to monitor accelerometer
-    g_engine.InitSensors();
-
-    // loop waiting for stuff to do.
-    while( 1 )
-    {
-        // Read all pending events.
-        int id;
-        int events;
-        android_poll_source* source;
-
-        // If not animating, we will block forever waiting for events.
-        // If animating, we loop until all events are read, then continue
-        // to draw the next frame of animation.
-        while( (id = ALooper_pollAll( g_engine.IsReady() ? 0 : -1, NULL, &events, (void**) &source ))
-                >= 0 )
-        {
-            // Process this event.
-            if( source != NULL )
-                source->process( state, source );
-
-            g_engine.ProcessSensors( id );
-
-            // Check if we are exiting.
-            if( state->destroyRequested != 0 )
-            {
-                g_engine.TermDisplay();
-                return;
-            }
-        }
-
-        if( g_engine.IsReady() )
-        {
-            // Drawing is throttled to the screen update rate, so there
-            // is no need to do timing here.
-            g_engine.DrawFrame();
-        }
-    }
-}
-

MoreTeapots/jni/MoreTeapotsRenderer.cpp

@@ -1,555 +0,0 @@
-/*
- * Copyright 2013 The Android Open Source Project
- *
- * 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.
- */
-
-//--------------------------------------------------------------------------------
-// MoreTeapotsRenderer.cpp
-// Render teapots
-//--------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------
-// Include files
-//--------------------------------------------------------------------------------
-#include "MoreTeapotsRenderer.h"
-
-//--------------------------------------------------------------------------------
-// Teapot model data
-//--------------------------------------------------------------------------------
-#include "teapot.inl"
-
-//--------------------------------------------------------------------------------
-// Ctor
-//--------------------------------------------------------------------------------
-MoreTeapotsRenderer::MoreTeapotsRenderer() :
-                geometry_instancing_support_( false )
-{
-
-}
-
-//--------------------------------------------------------------------------------
-// Dtor
-//--------------------------------------------------------------------------------
-MoreTeapotsRenderer::~MoreTeapotsRenderer()
-{
-    Unload();
-}
-
-//--------------------------------------------------------------------------------
-// Init
-//--------------------------------------------------------------------------------
-void MoreTeapotsRenderer::Init( const int32_t numX,
-        const int32_t numY,
-        const int32_t numZ )
-{
-    if( ndk_helper::GLContext::GetInstance()->GetGLVersion() >= 3.0 )
-    {
-        geometry_instancing_support_ = true;
-    }
-    else if( ndk_helper::GLContext::GetInstance()->CheckExtension( "GL_NV_draw_instanced" )
-            && ndk_helper::GLContext::GetInstance()->CheckExtension(
-                    "GL_NV_uniform_buffer_object" ) )
-    {
-        LOGI( "Supported via extension!" );
-        //_bGeometryInstancingSupport = true;
-        //_bARBSupport = true; //Need to patch shaders
-        //Currently this has been disabled
-    }
-
-    //Settings
-    glFrontFace( GL_CCW );
-
-    //Create Index buffer
-    num_indices_ = sizeof(teapotIndices) / sizeof(teapotIndices[0]);
-    glGenBuffers( 1, &ibo_ );
-    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, ibo_ );
-    glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof(teapotIndices), teapotIndices, GL_STATIC_DRAW );
-    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
-
-    //Create VBO
-    num_vertices_ = sizeof(teapotPositions) / sizeof(teapotPositions[0]) / 3;
-    int32_t iStride = sizeof(TEAPOT_VERTEX);
-    int32_t iIndex = 0;
-    TEAPOT_VERTEX* p = new TEAPOT_VERTEX[num_vertices_];
-    for( int32_t i = 0; i < num_vertices_; ++i )
-    {
-        p[i].pos[0] = teapotPositions[iIndex];
-        p[i].pos[1] = teapotPositions[iIndex + 1];
-        p[i].pos[2] = teapotPositions[iIndex + 2];
-
-        p[i].normal[0] = teapotNormals[iIndex];
-        p[i].normal[1] = teapotNormals[iIndex + 1];
-        p[i].normal[2] = teapotNormals[iIndex + 2];
-        iIndex += 3;
-    }
-    glGenBuffers( 1, &vbo_ );
-    glBindBuffer( GL_ARRAY_BUFFER, vbo_ );
-    glBufferData( GL_ARRAY_BUFFER, iStride * num_vertices_, p, GL_STATIC_DRAW );
-    glBindBuffer( GL_ARRAY_BUFFER, 0 );
-    delete[] p;
-
-    //Init Projection matrices
-    teapot_x_ = numX;
-    teapot_y_ = numY;
-    teapot_z_ = numZ;
-    vec_mat_models_.reserve( teapot_x_ * teapot_y_ * teapot_z_ );
-
-    UpdateViewport();
-
-    const float total_width = 500.f;
-    float gap_x = total_width / (teapot_x_ - 1);
-    float gap_y = total_width / (teapot_y_ - 1);
-    float gap_z = total_width / (teapot_z_ - 1);
-    float offset_x = -total_width / 2.f;
-    float offset_y = -total_width / 2.f;
-    float offset_z = -total_width / 2.f;
-
-    for( int32_t iX = 0; iX < teapot_x_; ++iX )
-        for( int32_t iY = 0; iY < teapot_y_; ++iY )
-            for( int32_t iZ = 0; iZ < teapot_z_; ++iZ )
-            {
-                vec_mat_models_.push_back(
-                        ndk_helper::Mat4::Translation( iX * gap_x + offset_x, iY * gap_y + offset_y,
-                                iZ * gap_z + offset_z ) );
-                vec_colors_.push_back(
-                        ndk_helper::Vec3( random() / float( RAND_MAX * 1.1 ),
-                                random() / float( RAND_MAX * 1.1 ),
-                                random() / float( RAND_MAX * 1.1 ) ) );
-
-                float fX = random() / float( RAND_MAX ) - 0.5f;
-                float fY = random() / float( RAND_MAX ) - 0.5f;
-                vec_rotations_.push_back( ndk_helper::Vec2( fX * 0.05f, fY * 0.05f ) );
-                vec_current_rotations_.push_back( ndk_helper::Vec2( fX * M_PI, fY * M_PI ) );
-            }
-
-    if( geometry_instancing_support_ )
-    {
-        //
-        //Create parameter dictionary for shader patch
-        std::map<std::string, std::string> param;
-        param[std::string( "%NUM_TEAPOT%" )] = ToString( teapot_x_ * teapot_y_ * teapot_z_ );
-        param[std::string( "%LOCATION_VERTEX%" )] = ToString( ATTRIB_VERTEX );
-        param[std::string( "%LOCATION_NORMAL%" )] = ToString( ATTRIB_NORMAL );
-        if( arb_support_ )
-            param[std::string( "%ARB%" )] = std::string( "ARB" );
-        else
-            param[std::string( "%ARB%" )] = std::string( "" );
-
-        //Load shader
-        bool b = LoadShadersES3( &shader_param_, "Shaders/VS_ShaderPlainES3.vsh",
-                "Shaders/ShaderPlainES3.fsh", param );
-        if( b )
-        {
-            //
-            //Create uniform buffer
-            //
-            GLuint bindingPoint = 1;
-            GLuint blockIndex;
-            blockIndex = glGetUniformBlockIndex( shader_param_.program_, "ParamBlock" );
-            glUniformBlockBinding( shader_param_.program_, blockIndex, bindingPoint );
-
-            //Retrieve array stride value
-            int32_t iNumIndices;
-            glGetActiveUniformBlockiv( shader_param_.program_, blockIndex,
-                    GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &iNumIndices );
-            GLint i[iNumIndices];
-            GLint stride[iNumIndices];
-            glGetActiveUniformBlockiv( shader_param_.program_, blockIndex,
-                    GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, i );
-            glGetActiveUniformsiv( shader_param_.program_, iNumIndices, (GLuint*) i,
-                    GL_UNIFORM_ARRAY_STRIDE, stride );
-
-            ubo_matrix_stride_ = stride[0] / sizeof(float);
-            ubo_vector_stride_ = stride[2] / sizeof(float);
-
-            glGenBuffers( 1, &ubo_ );
-            glBindBuffer( GL_UNIFORM_BUFFER, ubo_ );
-            glBindBufferBase( GL_UNIFORM_BUFFER, bindingPoint, ubo_ );
-
-            //Store color value which wouldn't be updated every frame
-            int32_t iSize = teapot_x_ * teapot_y_ * teapot_z_
-                    * (ubo_matrix_stride_ + ubo_matrix_stride_ + ubo_vector_stride_); //Mat4 + Mat4 + Vec3 + 1 stride
-            float* pBuffer = new float[iSize];
-            float* pColor = pBuffer + teapot_x_ * teapot_y_ * teapot_z_ * ubo_matrix_stride_ * 2;
-            for( int32_t i = 0; i < teapot_x_ * teapot_y_ * teapot_z_; ++i )
-            {
-                memcpy( pColor, &vec_colors_[i], 3 * sizeof(float) );
-                pColor += ubo_vector_stride_; //Assuming std140 layout which is 4 DWORD stride for vectors
-            }
-
-            glBufferData( GL_UNIFORM_BUFFER, iSize * sizeof(float), pBuffer, GL_DYNAMIC_DRAW );
-            delete[] pBuffer;
-        }
-        else
-        {
-            LOGI( "Shader compilation failed!! Falls back to ES2.0 pass" );
-            //This happens some devices.
-            geometry_instancing_support_ = false;
-            //Load shader for GLES2.0
-            LoadShaders( &shader_param_, "Shaders/VS_ShaderPlain.vsh", "Shaders/ShaderPlain.fsh" );
-        }
-    }
-    else
-    {
-        //Load shader for GLES2.0
-        LoadShaders( &shader_param_, "Shaders/VS_ShaderPlain.vsh", "Shaders/ShaderPlain.fsh" );
-    }
-}
-
-void MoreTeapotsRenderer::UpdateViewport()
-{
-    int32_t viewport[4];
-    glGetIntegerv( GL_VIEWPORT, viewport );
-    float fAspect = (float) viewport[2] / (float) viewport[3];
-
-    const float CAM_NEAR = 5.f;
-    const float CAM_FAR = 10000.f;
-    bool bRotate = false;
-    mat_projection_ = ndk_helper::Mat4::Perspective( fAspect, 1.f, CAM_NEAR, CAM_FAR );
-}
-
-//--------------------------------------------------------------------------------
-// Unload
-//--------------------------------------------------------------------------------
-void MoreTeapotsRenderer::Unload()
-{
-    if( vbo_ )
-    {
-        glDeleteBuffers( 1, &vbo_ );
-        vbo_ = 0;
-    }
-    if( ubo_ )
-    {
-        glDeleteBuffers( 1, &ubo_ );
-        ubo_ = 0;
-    }
-    if( ibo_ )
-    {
-        glDeleteBuffers( 1, &ibo_ );
-        ibo_ = 0;
-    }
-    if( shader_param_.program_ )
-    {
-        glDeleteProgram( shader_param_.program_ );
-        shader_param_.program_ = 0;
-    }
-}
-
-//--------------------------------------------------------------------------------
-// Update
-//--------------------------------------------------------------------------------
-void MoreTeapotsRenderer::Update( float fTime )
-{
-    const float CAM_X = 0.f;
-    const float CAM_Y = 0.f;
-    const float CAM_Z = 2000.f;
-
-    mat_view_ = ndk_helper::Mat4::LookAt( ndk_helper::Vec3( CAM_X, CAM_Y, CAM_Z ),
-            ndk_helper::Vec3( 0.f, 0.f, 0.f ), ndk_helper::Vec3( 0.f, 1.f, 0.f ) );
-
-    if( camera_ )
-    {
-        camera_->Update();
-        mat_view_ = camera_->GetTransformMatrix() * mat_view_ * camera_->GetRotationMatrix();
-    }
-}
-
-//--------------------------------------------------------------------------------
-// Render
-//--------------------------------------------------------------------------------
-void MoreTeapotsRenderer::Render()
-{
-    // Bind the VBO
-    glBindBuffer( GL_ARRAY_BUFFER, vbo_ );
-
-    int32_t iStride = sizeof(TEAPOT_VERTEX);
-    // Pass the vertex data
-    glVertexAttribPointer( ATTRIB_VERTEX, 3, GL_FLOAT, GL_FALSE, iStride, BUFFER_OFFSET( 0 ) );
-    glEnableVertexAttribArray( ATTRIB_VERTEX );
-
-    glVertexAttribPointer( ATTRIB_NORMAL, 3, GL_FLOAT, GL_FALSE, iStride,
-            BUFFER_OFFSET( 3 * sizeof(GLfloat) ) );
-    glEnableVertexAttribArray( ATTRIB_NORMAL );
-
-    // Bind the IB
-    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, ibo_ );
-
-    glUseProgram( shader_param_.program_ );
-
-    TEAPOT_MATERIALS material = { { 1.0f, 1.0f, 1.0f, 10.f }, { 0.1f, 0.1f, 0.1f }, };
-
-    //Update uniforms
-    //
-    //using glUniform3fv here was troublesome..
-    //
-    glUniform4f( shader_param_.material_specular_, material.specular_color[0],
-            material.specular_color[1], material.specular_color[2], material.specular_color[3] );
-    glUniform3f( shader_param_.material_ambient_, material.ambient_color[0],
-            material.ambient_color[1], material.ambient_color[2] );
-
-    glUniform3f( shader_param_.light0_, 100.f, -200.f, -600.f );
-
-    if( geometry_instancing_support_ )
-    {
-        //
-        //Geometry instancing, new feature in GLES3.0
-        //
-
-        //Update UBO
-        glBindBuffer( GL_UNIFORM_BUFFER, ubo_ );
-        float* p = (float*) glMapBufferRange( GL_UNIFORM_BUFFER, 0,
-                teapot_x_ * teapot_y_ * teapot_z_ * (ubo_matrix_stride_ * 2) * sizeof(float),
-                GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT );
-        float* pMVPMat = p;
-        float* pMVMat = p + teapot_x_ * teapot_y_ * teapot_z_ * ubo_matrix_stride_;
-        for( int32_t i = 0; i < teapot_x_ * teapot_y_ * teapot_z_; ++i )
-        {
-            //Rotation
-            float fX, fY;
-            vec_current_rotations_[i] += vec_rotations_[i];
-            vec_current_rotations_[i].Value( fX, fY );
-            ndk_helper::Mat4 mat_rotation = ndk_helper::Mat4::RotationX( fX )
-                    * ndk_helper::Mat4::RotationY( fY );
-
-            // Feed Projection and Model View matrices to the shaders
-            ndk_helper::Mat4 mat_v = mat_view_ * vec_mat_models_[i] * mat_rotation;
-            ndk_helper::Mat4 mat_vp = mat_projection_ * mat_v;
-
-            memcpy( pMVPMat, mat_vp.Ptr(), sizeof(mat_v) );
-            pMVPMat += ubo_matrix_stride_;
-
-            memcpy( pMVMat, mat_v.Ptr(), sizeof(mat_v) );
-            pMVMat += ubo_matrix_stride_;
-        }
-        glUnmapBuffer( GL_UNIFORM_BUFFER );
-
-        //Instanced rendering
-        glDrawElementsInstanced( GL_TRIANGLES, num_indices_, GL_UNSIGNED_SHORT, BUFFER_OFFSET(0),
-                teapot_x_ * teapot_y_ * teapot_z_ );
-
-    }
-    else
-    {
-        //Regular rendering pass
-        for( int32_t i = 0; i < teapot_x_ * teapot_y_ * teapot_z_; ++i )
-        {
-            //Set diffuse
-            float x, y, z;
-            vec_colors_[i].Value( x, y, z );
-            glUniform4f( shader_param_.material_diffuse_, x, y, z, 1.f );
-
-            //Rotation
-            vec_current_rotations_[i] += vec_rotations_[i];
-            vec_current_rotations_[i].Value( x, y );
-            ndk_helper::Mat4 mat_rotation = ndk_helper::Mat4::RotationX( x )
-                    * ndk_helper::Mat4::RotationY( y );
-
-            // Feed Projection and Model View matrices to the shaders
-            ndk_helper::Mat4 mat_v = mat_view_ * vec_mat_models_[i] * mat_rotation;
-            ndk_helper::Mat4 mat_vp = mat_projection_ * mat_v;
-            glUniformMatrix4fv( shader_param_.matrix_projection_, 1, GL_FALSE, mat_vp.Ptr() );
-            glUniformMatrix4fv( shader_param_.matrix_view_, 1, GL_FALSE, mat_v.Ptr() );
-
-            glDrawElements( GL_TRIANGLES, num_indices_, GL_UNSIGNED_SHORT, BUFFER_OFFSET(0) );
-
-        }
-    }
-
-    glBindBuffer( GL_ARRAY_BUFFER, 0 );
-    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
-}
-
-//--------------------------------------------------------------------------------
-// LoadShaders
-//--------------------------------------------------------------------------------
-bool MoreTeapotsRenderer::LoadShaders( SHADER_PARAMS* params,
-        const char* strVsh,
-        const char* strFsh )
-{
-    //
-    //Shader load for GLES2
-    //In GLES2.0, shader attribute locations need to be explicitly specified before linking
-    //
-    GLuint program;
-    GLuint vertShader, fragShader;
-    char *vertShaderPathname, *fragShaderPathname;
-
-    // Create shader program
-    program = glCreateProgram();
-    LOGI( "Created Shader %d", program );
-
-    // Create and compile vertex shader
-    if( !ndk_helper::shader::CompileShader( &vertShader, GL_VERTEX_SHADER, strVsh ) )
-    {
-        LOGI( "Failed to compile vertex shader" );
-        glDeleteProgram( program );
-        return false;
-    }
-
-    // Create and compile fragment shader
-    if( !ndk_helper::shader::CompileShader( &fragShader, GL_FRAGMENT_SHADER, strFsh ) )
-    {
-        LOGI( "Failed to compile fragment shader" );
-        glDeleteProgram( program );
-        return false;
-    }
-
-    // Attach vertex shader to program
-    glAttachShader( program, vertShader );
-
-    // Attach fragment shader to program
-    glAttachShader( program, fragShader );
-
-    // Bind attribute locations
-    // this needs to be done prior to linking
-    glBindAttribLocation( program, ATTRIB_VERTEX, "myVertex" );
-    glBindAttribLocation( program, ATTRIB_NORMAL, "myNormal" );
-
-    // Link program
-    if( !ndk_helper::shader::LinkProgram( program ) )
-    {
-        LOGI( "Failed to link program: %d", program );
-
-        if( vertShader )
-        {
-            glDeleteShader( vertShader );
-            vertShader = 0;
-        }
-        if( fragShader )
-        {
-            glDeleteShader( fragShader );
-            fragShader = 0;
-        }
-        if( program )
-        {
-            glDeleteProgram( program );
-        }
-        return false;
-    }
-
-    // Get uniform locations
-    params->matrix_projection_ = glGetUniformLocation( program, "uPMatrix" );
-    params->matrix_view_ = glGetUniformLocation( program, "uMVMatrix" );
-
-    params->light0_ = glGetUniformLocation( program, "vLight0" );
-    params->material_diffuse_ = glGetUniformLocation( program, "vMaterialDiffuse" );
-    params->material_ambient_ = glGetUniformLocation( program, "vMaterialAmbient" );
-    params->material_specular_ = glGetUniformLocation( program, "vMaterialSpecular" );
-
-    // Release vertex and fragment shaders
-    if( vertShader )
-        glDeleteShader( vertShader );
-    if( fragShader )
-        glDeleteShader( fragShader );
-
-    params->program_ = program;
-    return true;
-}
-
-bool MoreTeapotsRenderer::LoadShadersES3( SHADER_PARAMS* params,
-        const char* strVsh,
-        const char* strFsh,
-        std::map<std::string, std::string>&shaderParams )
-{
-    //
-    //Shader load for GLES3
-    //In GLES3.0, shader attribute index can be described in a shader code directly with layout() attribute
-    //
-    GLuint program;
-    GLuint vertShader, fragShader;
-    char *vertShaderPathname, *fragShaderPathname;
-
-    // Create shader program
-    program = glCreateProgram();
-    LOGI( "Created Shader %d", program );
-
-    // Create and compile vertex shader
-    if( !ndk_helper::shader::CompileShader( &vertShader, GL_VERTEX_SHADER, strVsh, shaderParams ) )
-    {
-        LOGI( "Failed to compile vertex shader" );
-        glDeleteProgram( program );
-        return false;
-    }
-
-    // Create and compile fragment shader
-    if( !ndk_helper::shader::CompileShader( &fragShader, GL_FRAGMENT_SHADER, strFsh,
-            shaderParams ) )
-    {
-        LOGI( "Failed to compile fragment shader" );
-        glDeleteProgram( program );
-        return false;
-    }
-
-    // Attach vertex shader to program
-    glAttachShader( program, vertShader );
-
-    // Attach fragment shader to program
-    glAttachShader( program, fragShader );
-
-    // Link program
-    if( !ndk_helper::shader::LinkProgram( program ) )
-    {
-        LOGI( "Failed to link program: %d", program );
-
-        if( vertShader )
-        {
-            glDeleteShader( vertShader );
-            vertShader = 0;
-        }
-        if( fragShader )
-        {
-            glDeleteShader( fragShader );
-            fragShader = 0;
-        }
-        if( program )
-        {
-            glDeleteProgram( program );
-        }
-
-        return false;
-    }
-
-    // Get uniform locations
-    params->light0_ = glGetUniformLocation( program, "vLight0" );
-    params->material_ambient_ = glGetUniformLocation( program, "vMaterialAmbient" );
-    params->material_specular_ = glGetUniformLocation( program, "vMaterialSpecular" );
-
-    // Release vertex and fragment shaders
-    if( vertShader )
-        glDeleteShader( vertShader );
-    if( fragShader )
-        glDeleteShader( fragShader );
-
-    params->program_ = program;
-    return true;
-}
-
-//--------------------------------------------------------------------------------
-// Bind
-//--------------------------------------------------------------------------------
-bool MoreTeapotsRenderer::Bind( ndk_helper::TapCamera* camera )
-{
-    camera_ = camera;
-    return true;
-}
-
-//--------------------------------------------------------------------------------
-// Helper functions
-//--------------------------------------------------------------------------------
-std::string MoreTeapotsRenderer::ToString( const int32_t i )
-{
-    char str[64];
-    snprintf( str, sizeof(str), "%d", i );
-    return std::string( str );
-}
-

MoreTeapots/jni/MoreTeapotsRenderer.h

@@ -1,126 +0,0 @@
-/*
- * Copyright 2013 The Android Open Source Project
- *
- * 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.
- */
-
-//--------------------------------------------------------------------------------
-// MoreTeapotsRenderer.h
-// Renderer for teapots
-//--------------------------------------------------------------------------------
-#ifndef _MoreTeapotsRenderer_H
-#define _MoreTeapotsRenderer_H
-
-//--------------------------------------------------------------------------------
-// Include files
-//--------------------------------------------------------------------------------
-#include <jni.h>
-#include <errno.h>
-
-#include <vector>
-
-#include <EGL/egl.h>
-#include <GLES/gl.h>
-
-#include <android/sensor.h>
-#include <android/log.h>
-#include <android_native_app_glue.h>
-#include <android/native_window_jni.h>
-#include <cpu-features.h>
-
-#define CLASS_NAME "android/app/NativeActivity"
-#define APPLICATION_CLASS_NAME "com/sample/moreteapotss/MoreTeapotsApplication"
-
-#include "NDKHelper.h"
-
-#define BUFFER_OFFSET(i) ((char *)NULL + (i))
-
-struct TEAPOT_VERTEX
-{
-    float pos[3];
-    float normal[3];
-};
-
-enum SHADER_ATTRIBUTES
-{
-    ATTRIB_VERTEX, ATTRIB_NORMAL, ATTRIB_COLOR, ATTRIB_UV
-};
-
-struct SHADER_PARAMS
-{
-    GLuint program_;
-    GLuint light0_;
-    GLuint material_diffuse_;
-    GLuint material_ambient_;
-    GLuint material_specular_;
-
-    GLuint matrix_projection_;
-    GLuint matrix_view_;
-};
-
-struct TEAPOT_MATERIALS
-{
-    float specular_color[4];
-    float ambient_color[3];
-};
-
-class MoreTeapotsRenderer
-{
-    int32_t num_indices_;
-    int32_t num_vertices_;
-    GLuint ibo_;
-    GLuint vbo_;
-    GLuint ubo_;
-
-    SHADER_PARAMS shader_param_;
-    bool LoadShaders( SHADER_PARAMS* params,
-            const char* strVsh,
-            const char* strFsh );
-    bool LoadShadersES3( SHADER_PARAMS* params,
-            const char* strVsh,
-            const char* strFsh,
-            std::map<std::string, std::string>&shaderParameters );
-
-    ndk_helper::Mat4 mat_projection_;
-    ndk_helper::Mat4 mat_view_;
-    std::vector<ndk_helper::Mat4> vec_mat_models_;
-    std::vector<ndk_helper::Vec3> vec_colors_;
-    std::vector<ndk_helper::Vec2> vec_rotations_;
-    std::vector<ndk_helper::Vec2> vec_current_rotations_;
-
-    ndk_helper::TapCamera* camera_;
-
-    int32_t teapot_x_;
-    int32_t teapot_y_;
-    int32_t teapot_z_;
-    int32_t ubo_matrix_stride_;
-    int32_t ubo_vector_stride_;
-    bool geometry_instancing_support_;
-    bool arb_support_;
-
-    std::string ToString( const int32_t i );
-public:
-    MoreTeapotsRenderer();
-    virtual ~MoreTeapotsRenderer();
-    void Init( const int32_t numX,
-            const int32_t numY,
-            const int32_t numZ );
-    void Render();
-    void Update( float dTime );
-    bool Bind( ndk_helper::TapCamera* camera );
-    void Unload();
-    void UpdateViewport();
-};
-
-#endif
-

MoreTeapots/lint.xml

@@ -1,3 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<lint>
-</lint>

MoreTeapots/nativeactivity/build.gradle

@@ -0,0 +1,39 @@
+apply plugin: 'com.android.model.library'
+
+def ndkDir = System.getenv("ANDROID_NDK_HOME")
+def propertiesFile = project.rootProject.file('local.properties')
+if (propertiesFile.exists()) {
+    Properties properties = new Properties()
+    properties.load(propertiesFile.newDataInputStream())
+    ndkDir = properties.getProperty('ndk.dir')
+}
+
+model {
+    android {
+        compileSdkVersion = 23
+        buildToolsVersion = '23.0.2'
+        defaultConfig.with {
+            minSdkVersion.apiLevel = 9
+            targetSdkVersion.apiLevel = 23
+            versionCode = 1
+            versionName = '0.0.1'
+        }
+        ndk {
+            moduleName = 'native-activity'
+            ldLibs.addAll(['log', 'android'])
+            ldFlags.add('-c')
+        }
+        sources {
+            main {
+                jni {
+                    source {
+                        srcDir "${ndkDir}/sources/android/native_app_glue"
+                    }
+                    exportedHeaders {
+                        srcDir "${ndkDir}/sources/android/native_app_glue"
+                    }
+                }
+            }
+        }
+    }
+}

MoreTeapots/nativeactivity/src/main/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="native_activity.android.example.com.nativeactivity">
+
+    <application>
+    </application>
+
+</manifest>

MoreTeapots/project.properties

@@ -1,14 +0,0 @@
-# This file is automatically generated by Android Tools.
-# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-#
-# This file must be checked in Version Control Systems.
-#
-# To customize properties used by the Ant build system edit
-# "ant.properties", and override values to adapt the script to your
-# project structure.
-#
-# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
-#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
-
-# Project target.
-target=Google Inc.:Google APIs:19

MoreTeapots/settings.gradle

@@ -0,0 +1,2 @@
+include ':app'
+include ':nativeactivity'

README.md

@@ -1,35 +1,11 @@
-NDK Samples
-===========
 
-This repository contains samples for [Android NDK][0].
-
-Pre-requisites
---------------
-
-- [Android NDK][0]
-
-Getting Started
----------------
-
-These samples use the NDK build system, you can build them by
-following the instructions in the
-[NDK documentation](https://developer.android.com/tools/sdk/ndk/index.html#Samples).
-
-Support
--------
-
-- [Google+ Community](https://plus.google.com/communities/105153134372062985968)
-- [Stack Overflow](http://stackoverflow.com/questions/tagged/android)
-
-If you've found an error in this sample, please [file an issue](https://github.com/googlesamples/android-ndk/issues/new).
-
-Patches are encouraged, and may be submitted by [forking this project](https://github.com/googlesamples/android-ndk/fork) and
-submitting a pull request through GitHub. Please see [CONTRIBUTING.md](CONTRIBUTING.md) for more details.
+**NOTE**    
+**This branch is forzen on 04/22/2016 from master branch; new update should be checked in to master branch**    
 
 License
 -------
 
-Copyright 2015 The Android Open Source Project, Inc.
+Copyright 2018 The Android Open Source Project, Inc.
 
 Licensed to the Apache Software Foundation (ASF) under one or more contributor
 license agreements.  See the NOTICE file distributed with this work for
@@ -46,6 +22,3 @@ WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 License for the specific language governing permissions and limitations under
 the License.
 
-[LICENSE](LICENSE)
-
-[0]: https://developer.android.com/tools/sdk/ndk/

Teapot/.google/packaging.yaml

@@ -0,0 +1,7 @@
+status:       PUBLISHED
+technologies: [Android, NDK]
+categories:   [NDK, C++]
+languages:    [C++, Java]
+solutions:    [Mobile]
+github:       googlesamples/android-ndk
+license:      apache2

Teapot/AndroidManifest.xml

@@ -1,34 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.sample.teapot"
-    android:versionCode="1"
-    android:versionName="1.0" >
-
-    <uses-sdk
-        android:minSdkVersion="11"
-        android:targetSdkVersion="19" />
-    <uses-feature android:glEsVersion="0x00020000"></uses-feature>
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
-    <application
-        android:allowBackup="true"
-        android:icon="@drawable/ic_launcher"
-        android:label="@string/app_name"
-        android:theme="@style/AppTheme"
-        android:hasCode="true"
-        android:name="com.sample.teapot.TeapotApplication"
-        >
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="com.sample.teapot.TeapotNativeActivity"
-                android:label="@string/app_name"
-                android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of or .so -->
-            <meta-data android:name="android.app.lib_name"
-                    android:value="TeapotNativeActivity" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>

Teapot/README.md

@@ -0,0 +1,53 @@
+Teapot
+======
+Teapot is an Android C++ sample that draws a Teapot mesh using GLES 2.0 API and [NativeActivity](http://developer.android.com/reference/android/app/NativeActivity.html).
+
+This sample uses the new [Gradle Experimental Android plugin](http://tools.android.com/tech-docs/new-build-system/gradle-experimental) with C++ support.
+
+Pre-requisites
+--------------
+- Android Studio 1.3+ with [NDK](https://developer.android.com/ndk/) bundle.
+
+Getting Started
+---------------
+1. [Download Android Studio](http://developer.android.com/sdk/index.html)
+1. Launch Android Studio.
+1. Open the sample directory.
+1. Open *File/Project Structure...*
+  - Click *Download* or *Select NDK location*.
+1. Click *Tools/Android/Sync Project with Gradle Files*.
+1. Click *Run/Run 'app'*.
+
+Screenshots
+-----------
+![screenshot](screenshot.png)
+
+Support
+-------
+If you've found an error in these samples, please [file an issue](https://github.com/googlesamples/android-ndk/issues/new).
+
+Patches are encouraged, and may be submitted by [forking this project](https://github.com/googlesamples/android-ndk/fork) and
+submitting a pull request through GitHub. Please see [CONTRIBUTING.md](../CONTRIBUTING.md) for more details.
+
+- [Stack Overflow](http://stackoverflow.com/questions/tagged/android-ndk)
+- [Google+ Community](https://plus.google.com/communities/105153134372062985968)
+- [Android Tools Feedbacks](http://tools.android.com/feedback)
+
+License
+-------
+Copyright 2015 Google, Inc.
+
+Licensed to the Apache Software Foundation (ASF) under one or more contributor
+license agreements.  See the NOTICE file distributed with this work for
+additional information regarding copyright ownership.  The ASF licenses this
+file to you 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.

Teapot/app/build.gradle

@@ -0,0 +1,65 @@
+apply plugin: 'com.android.model.application'
+
+// Retrieve ndk path to config cpufeatures src code into this project
+// native_app_glue is configured as dependent module, so we avoid confusing
+// NOTICE/repo.prop files get displayed multiple times inside IDE
+def ndkDir = System.getenv("ANDROID_NDK_HOME")
+def propertiesFile = project.rootProject.file('local.properties')
+if (propertiesFile.exists()) {
+    Properties properties = new Properties()
+    properties.load(propertiesFile.newDataInputStream())
+    ndkDir = properties.getProperty('ndk.dir')
+}
+
+model {
+    android {
+        compileSdkVersion = 23
+        buildToolsVersion = '23.0.2'
+
+        defaultConfig {
+            applicationId = 'com.sample.teapot'
+            minSdkVersion.apiLevel = 17
+            targetSdkVersion.apiLevel = 22
+        }
+        ndk {
+            moduleName = 'TeapotNativeActivity'
+            // temporarily use gcc since clang does not work on windows (*)
+            // also clang warning about inline, so could not use -Wall, -Werror
+            // toolchain = "clang"
+            stl       = 'gnustl_static'
+            cppFlags.addAll(['-I' + "${ndkDir}/sources/android/cpufeatures",
+                             '-I' + file('src/main/jni/ndk_helper')])
+            cppFlags.addAll(['-std=c++11', '-Werror', '-Wall',
+                             '-fno-exceptions', '-fno-rtti'])
+            ldLibs.addAll(['android', 'log', 'EGL', 'GLESv2','atomic'])
+        }
+        // Turn on hard float support in armeabi-v7a
+        abis {
+            create('armeabi-v7a') {
+                cppFlags.addAll(['-mhard-float', '-D_NDK_MATH_NO_SOFTFP=1',
+                                 '-mfloat-abi=hard'])
+                ldLibs.add('m_hard')
+                ldFlags.add('-Wl,--no-warn-mismatch')
+            }
+        }
+        sources {
+            main {
+                jni {
+                    dependencies {
+                        project ':nativeactivity' linkage 'static'
+                    }
+                    source {
+                        srcDirs 'src/main/jni'
+                        srcDirs "${ndkDir}/sources/android/cpufeatures"
+                    }
+                }
+            }
+        }
+        buildTypes {
+            release {
+                minifyEnabled = false
+                proguardFiles.add(file('proguard-rules.txt'))
+            }
+        }
+    }
+}

Teapot/app/src/main/AndroidManifest.xml

@@ -0,0 +1,33 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.sample.teapot"
+          android:versionCode="1"
+          android:versionName="1.0" >
+
+  <uses-feature android:glEsVersion="0x00020000"></uses-feature>
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
+
+  <application
+      android:allowBackup="false"
+      android:fullBackupContent="false"
+      android:supportsRtl="true"
+      android:icon="@mipmap/ic_launcher"
+      android:label="@string/app_name"
+      android:theme="@style/AppTheme"
+      android:name="com.sample.teapot.TeapotApplication"
+      >
+
+    <!-- Our activity is the built-in NativeActivity framework class.
+         This will take care of integrating with our NDK code. -->
+    <activity android:name="com.sample.teapot.TeapotNativeActivity"
+              android:label="@string/app_name"
+              android:configChanges="orientation|keyboardHidden">
+      <!-- Tell NativeActivity the name of or .so -->
+      <meta-data android:name="android.app.lib_name"
+                 android:value="TeapotNativeActivity" />
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+    </activity>
+  </application>
+</manifest>

Teapot/app/src/main/java/com/sample/helper/NDKHelper.java

@@ -21,6 +21,7 @@ import java.io.FileInputStream;
 
 import javax.microedition.khronos.opengles.GL10;
 
+import android.annotation.TargetApi;
 import android.content.Context;
 import android.content.pm.ApplicationInfo;
 import android.graphics.Bitmap;
@@ -178,6 +179,7 @@ public class NDKHelper
         return "/system/lib/";
     }
 
+    @TargetApi(17)    
     public int getNativeAudioBufferSize()
     {
         int SDK_INT = android.os.Build.VERSION.SDK_INT;
@@ -199,4 +201,5 @@ public class NDKHelper
         return AudioTrack.getNativeOutputSampleRate(AudioManager.STREAM_SYSTEM);
 
     }
+
 }

Teapot/app/src/main/java/com/sample/teapot/TeapotApplication.java

@@ -32,6 +32,7 @@ import android.widget.Toast;
 
 public class TeapotApplication extends Application {
     public void onCreate(){
+        super.onCreate();	
         Log.w("native-activity", "onCreate");
 
         final PackageManager pm = getApplicationContext().getPackageManager();

Teapot/app/src/main/java/com/sample/teapot/TeapotNativeActivity.java

@@ -16,6 +16,8 @@
 
 package com.sample.teapot;
 
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
 import android.app.NativeActivity;
 import android.os.Bundle;
 import android.view.Gravity;
@@ -49,6 +51,7 @@ public class TeapotNativeActivity extends NativeActivity {
 
     }
 
+    @TargetApi(19)    
     protected void onResume() {
         super.onResume();
 
@@ -70,6 +73,7 @@ public class TeapotNativeActivity extends NativeActivity {
     }
     // Our popup window, you will call it from your C/C++ code later
 
+    @TargetApi(19)    
     void setImmersiveSticky() {
         View decorView = getWindow().getDecorView();
         decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_FULLSCREEN
@@ -84,6 +88,7 @@ public class TeapotNativeActivity extends NativeActivity {
     PopupWindow _popupWindow;
     TextView _label;
 
+    @SuppressLint("InflateParams")
     public void showUI()
     {
         if( _popupWindow != null )
@@ -109,7 +114,7 @@ public class TeapotNativeActivity extends NativeActivity {
                 _activity.setContentView(mainLayout, params);
 
                 // Show our UI over NativeActivity window
-                _popupWindow.showAtLocation(mainLayout, Gravity.TOP | Gravity.LEFT, 10, 10);
+                _popupWindow.showAtLocation(mainLayout, Gravity.TOP | Gravity.START, 10, 10);
                 _popupWindow.update();
 
                 _label = (TextView)popupView.findViewById(R.id.textViewFPS);
@@ -120,10 +125,6 @@ public class TeapotNativeActivity extends NativeActivity {
     protected void onPause()
     {
         super.onPause();
-        if (_popupWindow != null) {
-            _popupWindow.dismiss();
-            _popupWindow = null;
-        }
     }
 
     public void updateFPS(final float fFPS)

Teapot/app/src/main/jni/TeapotNativeActivity.cpp

@@ -0,0 +1,427 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 files
+//--------------------------------------------------------------------------------
+#include <jni.h>
+#include <errno.h>
+
+#include <android/sensor.h>
+#include <android/log.h>
+#include <android_native_app_glue.h>
+#include <android/native_window_jni.h>
+#include <cpu-features.h>
+
+#include "TeapotRenderer.h"
+#include "NDKHelper.h"
+
+//-------------------------------------------------------------------------
+// Preprocessor
+//-------------------------------------------------------------------------
+#define HELPER_CLASS_NAME \
+  "com/sample/helper/NDKHelper"  // Class name of helper function
+//-------------------------------------------------------------------------
+// Shared state for our app.
+//-------------------------------------------------------------------------
+struct android_app;
+class Engine {
+  TeapotRenderer renderer_;
+
+  ndk_helper::GLContext* gl_context_;
+
+  bool initialized_resources_;
+  bool has_focus_;
+
+  ndk_helper::DoubletapDetector doubletap_detector_;
+  ndk_helper::PinchDetector pinch_detector_;
+  ndk_helper::DragDetector drag_detector_;
+  ndk_helper::PerfMonitor monitor_;
+
+  ndk_helper::TapCamera tap_camera_;
+
+  android_app* app_;
+
+  ASensorManager* sensor_manager_;
+  const ASensor* accelerometer_sensor_;
+  ASensorEventQueue* sensor_event_queue_;
+
+  void UpdateFPS(float fFPS);
+  void ShowUI();
+  void TransformPosition(ndk_helper::Vec2& vec);
+
+ public:
+  static void HandleCmd(struct android_app* app, int32_t cmd);
+  static int32_t HandleInput(android_app* app, AInputEvent* event);
+
+  Engine();
+  ~Engine();
+  void SetState(android_app* state);
+  int InitDisplay();
+  void LoadResources();
+  void UnloadResources();
+  void DrawFrame();
+  void TermDisplay();
+  void TrimMemory();
+  bool IsReady();
+
+  void UpdatePosition(AInputEvent* event, int32_t iIndex, float& fX, float& fY);
+
+  void InitSensors();
+  void ProcessSensors(int32_t id);
+  void SuspendSensors();
+  void ResumeSensors();
+};
+
+//-------------------------------------------------------------------------
+// Ctor
+//-------------------------------------------------------------------------
+Engine::Engine()
+    : initialized_resources_(false),
+      has_focus_(false),
+      app_(NULL),
+      sensor_manager_(NULL),
+      accelerometer_sensor_(NULL),
+      sensor_event_queue_(NULL) {
+  gl_context_ = ndk_helper::GLContext::GetInstance();
+}
+
+//-------------------------------------------------------------------------
+// Dtor
+//-------------------------------------------------------------------------
+Engine::~Engine() {}
+
+/**
+ * Load resources
+ */
+void Engine::LoadResources() {
+  renderer_.Init();
+  renderer_.Bind(&tap_camera_);
+}
+
+/**
+ * Unload resources
+ */
+void Engine::UnloadResources() { renderer_.Unload(); }
+
+/**
+ * Initialize an EGL context for the current display.
+ */
+int Engine::InitDisplay() {
+  if (!initialized_resources_) {
+    gl_context_->Init(app_->window);
+    LoadResources();
+    initialized_resources_ = true;
+  } else {
+    // initialize OpenGL ES and EGL
+    if (EGL_SUCCESS != gl_context_->Resume(app_->window)) {
+      UnloadResources();
+      LoadResources();
+    }
+  }
+
+  ShowUI();
+
+  // Initialize GL state.
+  glEnable(GL_CULL_FACE);
+  glEnable(GL_DEPTH_TEST);
+  glDepthFunc(GL_LEQUAL);
+
+  // Note that screen size might have been changed
+  glViewport(0, 0, gl_context_->GetScreenWidth(),
+             gl_context_->GetScreenHeight());
+  renderer_.UpdateViewport();
+
+  tap_camera_.SetFlip(1.f, -1.f, -1.f);
+  tap_camera_.SetPinchTransformFactor(2.f, 2.f, 8.f);
+
+  return 0;
+}
+
+/**
+ * Just the current frame in the display.
+ */
+void Engine::DrawFrame() {
+  float fps;
+  if (monitor_.Update(fps)) {
+    UpdateFPS(fps);
+  }
+  renderer_.Update(monitor_.GetCurrentTime());
+
+  // Just fill the screen with a color.
+  glClearColor(0.5f, 0.5f, 0.5f, 1.f);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  renderer_.Render();
+
+  // Swap
+  if (EGL_SUCCESS != gl_context_->Swap()) {
+    UnloadResources();
+    LoadResources();
+  }
+}
+
+/**
+ * Tear down the EGL context currently associated with the display.
+ */
+void Engine::TermDisplay() { gl_context_->Suspend(); }
+
+void Engine::TrimMemory() {
+  LOGI("Trimming memory");
+  gl_context_->Invalidate();
+}
+/**
+ * Process the next input event.
+ */
+int32_t Engine::HandleInput(android_app* app, AInputEvent* event) {
+  Engine* eng = (Engine*)app->userData;
+  if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) {
+    ndk_helper::GESTURE_STATE doubleTapState =
+        eng->doubletap_detector_.Detect(event);
+    ndk_helper::GESTURE_STATE dragState = eng->drag_detector_.Detect(event);
+    ndk_helper::GESTURE_STATE pinchState = eng->pinch_detector_.Detect(event);
+
+    // Double tap detector has a priority over other detectors
+    if (doubleTapState == ndk_helper::GESTURE_STATE_ACTION) {
+      // Detect double tap
+      eng->tap_camera_.Reset(true);
+    } else {
+      // Handle drag state
+      if (dragState & ndk_helper::GESTURE_STATE_START) {
+        // Otherwise, start dragging
+        ndk_helper::Vec2 v;
+        eng->drag_detector_.GetPointer(v);
+        eng->TransformPosition(v);
+        eng->tap_camera_.BeginDrag(v);
+      } else if (dragState & ndk_helper::GESTURE_STATE_MOVE) {
+        ndk_helper::Vec2 v;
+        eng->drag_detector_.GetPointer(v);
+        eng->TransformPosition(v);
+        eng->tap_camera_.Drag(v);
+      } else if (dragState & ndk_helper::GESTURE_STATE_END) {
+        eng->tap_camera_.EndDrag();
+      }
+
+      // Handle pinch state
+      if (pinchState & ndk_helper::GESTURE_STATE_START) {
+        // Start new pinch
+        ndk_helper::Vec2 v1;
+        ndk_helper::Vec2 v2;
+        eng->pinch_detector_.GetPointers(v1, v2);
+        eng->TransformPosition(v1);
+        eng->TransformPosition(v2);
+        eng->tap_camera_.BeginPinch(v1, v2);
+      } else if (pinchState & ndk_helper::GESTURE_STATE_MOVE) {
+        // Multi touch
+        // Start new pinch
+        ndk_helper::Vec2 v1;
+        ndk_helper::Vec2 v2;
+        eng->pinch_detector_.GetPointers(v1, v2);
+        eng->TransformPosition(v1);
+        eng->TransformPosition(v2);
+        eng->tap_camera_.Pinch(v1, v2);
+      }
+    }
+    return 1;
+  }
+  return 0;
+}
+
+/**
+ * Process the next main command.
+ */
+void Engine::HandleCmd(struct android_app* app, int32_t cmd) {
+  Engine* eng = (Engine*)app->userData;
+  switch (cmd) {
+    case APP_CMD_SAVE_STATE:
+      break;
+    case APP_CMD_INIT_WINDOW:
+      // The window is being shown, get it ready.
+      if (app->window != NULL) {
+        eng->InitDisplay();
+        eng->DrawFrame();
+      }
+      break;
+    case APP_CMD_TERM_WINDOW:
+      // The window is being hidden or closed, clean it up.
+      eng->TermDisplay();
+      eng->has_focus_ = false;
+      break;
+    case APP_CMD_STOP:
+      break;
+    case APP_CMD_GAINED_FOCUS:
+      eng->ResumeSensors();
+      // Start animation
+      eng->has_focus_ = true;
+      break;
+    case APP_CMD_LOST_FOCUS:
+      eng->SuspendSensors();
+      // Also stop animating.
+      eng->has_focus_ = false;
+      eng->DrawFrame();
+      break;
+    case APP_CMD_LOW_MEMORY:
+      // Free up GL resources
+      eng->TrimMemory();
+      break;
+  }
+}
+
+//-------------------------------------------------------------------------
+// Sensor handlers
+//-------------------------------------------------------------------------
+void Engine::InitSensors() {
+  sensor_manager_ = ASensorManager_getInstance();
+  accelerometer_sensor_ = ASensorManager_getDefaultSensor(
+      sensor_manager_, ASENSOR_TYPE_ACCELEROMETER);
+  sensor_event_queue_ = ASensorManager_createEventQueue(
+      sensor_manager_, app_->looper, LOOPER_ID_USER, NULL, NULL);
+}
+
+void Engine::ProcessSensors(int32_t id) {
+  // If a sensor has data, process it now.
+  if (id == LOOPER_ID_USER) {
+    if (accelerometer_sensor_ != NULL) {
+      ASensorEvent event;
+      while (ASensorEventQueue_getEvents(sensor_event_queue_, &event, 1) > 0) {
+      }
+    }
+  }
+}
+
+void Engine::ResumeSensors() {
+  // When our app gains focus, we start monitoring the accelerometer.
+  if (accelerometer_sensor_ != NULL) {
+    ASensorEventQueue_enableSensor(sensor_event_queue_, accelerometer_sensor_);
+    // We'd like to get 60 events per second (in us).
+    ASensorEventQueue_setEventRate(sensor_event_queue_, accelerometer_sensor_,
+                                   (1000L / 60) * 1000);
+  }
+}
+
+void Engine::SuspendSensors() {
+  // When our app loses focus, we stop monitoring the accelerometer.
+  // This is to avoid consuming battery while not being used.
+  if (accelerometer_sensor_ != NULL) {
+    ASensorEventQueue_disableSensor(sensor_event_queue_, accelerometer_sensor_);
+  }
+}
+
+//-------------------------------------------------------------------------
+// Misc
+//-------------------------------------------------------------------------
+void Engine::SetState(android_app* state) {
+  app_ = state;
+  doubletap_detector_.SetConfiguration(app_->config);
+  drag_detector_.SetConfiguration(app_->config);
+  pinch_detector_.SetConfiguration(app_->config);
+}
+
+bool Engine::IsReady() {
+  if (has_focus_) return true;
+
+  return false;
+}
+
+void Engine::TransformPosition(ndk_helper::Vec2& vec) {
+  vec = ndk_helper::Vec2(2.0f, 2.0f) * vec /
+            ndk_helper::Vec2(gl_context_->GetScreenWidth(),
+                             gl_context_->GetScreenHeight()) -
+        ndk_helper::Vec2(1.f, 1.f);
+}
+
+void Engine::ShowUI() {
+  JNIEnv* jni;
+  app_->activity->vm->AttachCurrentThread(&jni, NULL);
+
+  // Default class retrieval
+  jclass clazz = jni->GetObjectClass(app_->activity->clazz);
+  jmethodID methodID = jni->GetMethodID(clazz, "showUI", "()V");
+  jni->CallVoidMethod(app_->activity->clazz, methodID);
+
+  app_->activity->vm->DetachCurrentThread();
+  return;
+}
+
+void Engine::UpdateFPS(float fFPS) {
+  JNIEnv* jni;
+  app_->activity->vm->AttachCurrentThread(&jni, NULL);
+
+  // Default class retrieval
+  jclass clazz = jni->GetObjectClass(app_->activity->clazz);
+  jmethodID methodID = jni->GetMethodID(clazz, "updateFPS", "(F)V");
+  jni->CallVoidMethod(app_->activity->clazz, methodID, fFPS);
+
+  app_->activity->vm->DetachCurrentThread();
+  return;
+}
+
+Engine g_engine;
+
+/**
+ * This is the main entry point of a native application that is using
+ * android_native_app_glue.  It runs in its own thread, with its own
+ * event loop for receiving input events and doing other things.
+ */
+void android_main(android_app* state) {
+  app_dummy();
+
+  g_engine.SetState(state);
+
+  // Init helper functions
+  ndk_helper::JNIHelper::Init(state->activity, HELPER_CLASS_NAME);
+
+  state->userData = &g_engine;
+  state->onAppCmd = Engine::HandleCmd;
+  state->onInputEvent = Engine::HandleInput;
+
+#ifdef USE_NDK_PROFILER
+  monstartup("libTeapotNativeActivity.so");
+#endif
+
+  // Prepare to monitor accelerometer
+  g_engine.InitSensors();
+
+  // loop waiting for stuff to do.
+  while (1) {
+    // Read all pending events.
+    int id;
+    int events;
+    android_poll_source* source;
+
+    // If not animating, we will block forever waiting for events.
+    // If animating, we loop until all events are read, then continue
+    // to draw the next frame of animation.
+    while ((id = ALooper_pollAll(g_engine.IsReady() ? 0 : -1, NULL, &events,
+                                 (void**)&source)) >= 0) {
+      // Process this event.
+      if (source != NULL) source->process(state, source);
+
+      g_engine.ProcessSensors(id);
+
+      // Check if we are exiting.
+      if (state->destroyRequested != 0) {
+        g_engine.TermDisplay();
+        return;
+      }
+    }
+
+    if (g_engine.IsReady()) {
+      // Drawing is throttled to the screen update rate, so there
+      // is no need to do timing here.
+      g_engine.DrawFrame();
+    }
+  }
+}

Teapot/app/src/main/jni/TeapotRenderer.cpp

@@ -0,0 +1,269 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//--------------------------------------------------------------------------------
+// TeapotRenderer.cpp
+// Render a teapot
+//--------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------
+// Include files
+//--------------------------------------------------------------------------------
+#include "TeapotRenderer.h"
+
+//--------------------------------------------------------------------------------
+// Teapot model data
+//--------------------------------------------------------------------------------
+#include "teapot.inl"
+
+//--------------------------------------------------------------------------------
+// Ctor
+//--------------------------------------------------------------------------------
+TeapotRenderer::TeapotRenderer() {}
+
+//--------------------------------------------------------------------------------
+// Dtor
+//--------------------------------------------------------------------------------
+TeapotRenderer::~TeapotRenderer() { Unload(); }
+
+void TeapotRenderer::Init() {
+  // Settings
+  glFrontFace(GL_CCW);
+
+  // Load shader
+  LoadShaders(&shader_param_, "Shaders/VS_ShaderPlain.vsh",
+              "Shaders/ShaderPlain.fsh");
+
+  // Create Index buffer
+  num_indices_ = sizeof(teapotIndices) / sizeof(teapotIndices[0]);
+  glGenBuffers(1, &ibo_);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(teapotIndices), teapotIndices,
+               GL_STATIC_DRAW);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+  // Create VBO
+  num_vertices_ = sizeof(teapotPositions) / sizeof(teapotPositions[0]) / 3;
+  int32_t stride = sizeof(TEAPOT_VERTEX);
+  int32_t index = 0;
+  TEAPOT_VERTEX* p = new TEAPOT_VERTEX[num_vertices_];
+  for (int32_t i = 0; i < num_vertices_; ++i) {
+    p[i].pos[0] = teapotPositions[index];
+    p[i].pos[1] = teapotPositions[index + 1];
+    p[i].pos[2] = teapotPositions[index + 2];
+
+    p[i].normal[0] = teapotNormals[index];
+    p[i].normal[1] = teapotNormals[index + 1];
+    p[i].normal[2] = teapotNormals[index + 2];
+    index += 3;
+  }
+  glGenBuffers(1, &vbo_);
+  glBindBuffer(GL_ARRAY_BUFFER, vbo_);
+  glBufferData(GL_ARRAY_BUFFER, stride * num_vertices_, p, GL_STATIC_DRAW);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+  delete[] p;
+
+  UpdateViewport();
+  mat_model_ = ndk_helper::Mat4::Translation(0, 0, -15.f);
+
+  ndk_helper::Mat4 mat = ndk_helper::Mat4::RotationX(M_PI / 3);
+  mat_model_ = mat * mat_model_;
+}
+
+void TeapotRenderer::UpdateViewport() {
+  // Init Projection matrices
+  int32_t viewport[4];
+  glGetIntegerv(GL_VIEWPORT, viewport);
+
+  const float CAM_NEAR = 5.f;
+  const float CAM_FAR = 10000.f;
+  if (viewport[2] < viewport[3]) {
+    float aspect =
+        static_cast<float>(viewport[2]) / static_cast<float>(viewport[3]);
+    mat_projection_ =
+        ndk_helper::Mat4::Perspective(aspect, 1.0f, CAM_NEAR, CAM_FAR);
+  } else {
+    float aspect =
+        static_cast<float>(viewport[3]) / static_cast<float>(viewport[2]);
+    mat_projection_ =
+        ndk_helper::Mat4::Perspective(1.0f, aspect, CAM_NEAR, CAM_FAR);
+  }
+}
+
+void TeapotRenderer::Unload() {
+  if (vbo_) {
+    glDeleteBuffers(1, &vbo_);
+    vbo_ = 0;
+  }
+
+  if (ibo_) {
+    glDeleteBuffers(1, &ibo_);
+    ibo_ = 0;
+  }
+
+  if (shader_param_.program_) {
+    glDeleteProgram(shader_param_.program_);
+    shader_param_.program_ = 0;
+  }
+}
+
+void TeapotRenderer::Update(float fTime) {
+  const float CAM_X = 0.f;
+  const float CAM_Y = 0.f;
+  const float CAM_Z = 700.f;
+
+  mat_view_ = ndk_helper::Mat4::LookAt(ndk_helper::Vec3(CAM_X, CAM_Y, CAM_Z),
+                                       ndk_helper::Vec3(0.f, 0.f, 0.f),
+                                       ndk_helper::Vec3(0.f, 1.f, 0.f));
+
+  if (camera_) {
+    camera_->Update();
+    mat_view_ = camera_->GetTransformMatrix() * mat_view_ *
+                camera_->GetRotationMatrix() * mat_model_;
+  } else {
+    mat_view_ = mat_view_ * mat_model_;
+  }
+}
+
+void TeapotRenderer::Render() {
+  //
+  // Feed Projection and Model View matrices to the shaders
+  ndk_helper::Mat4 mat_vp = mat_projection_ * mat_view_;
+
+  // Bind the VBO
+  glBindBuffer(GL_ARRAY_BUFFER, vbo_);
+
+  int32_t iStride = sizeof(TEAPOT_VERTEX);
+  // Pass the vertex data
+  glVertexAttribPointer(ATTRIB_VERTEX, 3, GL_FLOAT, GL_FALSE, iStride,
+                        BUFFER_OFFSET(0));
+  glEnableVertexAttribArray(ATTRIB_VERTEX);
+
+  glVertexAttribPointer(ATTRIB_NORMAL, 3, GL_FLOAT, GL_FALSE, iStride,
+                        BUFFER_OFFSET(3 * sizeof(GLfloat)));
+  glEnableVertexAttribArray(ATTRIB_NORMAL);
+
+  // Bind the IB
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_);
+
+  glUseProgram(shader_param_.program_);
+
+  TEAPOT_MATERIALS material = {
+      {1.0f, 0.5f, 0.5f}, {1.0f, 1.0f, 1.0f, 10.f}, {0.1f, 0.1f, 0.1f}, };
+
+  // Update uniforms
+  glUniform4f(shader_param_.material_diffuse_, material.diffuse_color[0],
+              material.diffuse_color[1], material.diffuse_color[2], 1.f);
+
+  glUniform4f(shader_param_.material_specular_, material.specular_color[0],
+              material.specular_color[1], material.specular_color[2],
+              material.specular_color[3]);
+  //
+  // using glUniform3fv here was troublesome
+  //
+  glUniform3f(shader_param_.material_ambient_, material.ambient_color[0],
+              material.ambient_color[1], material.ambient_color[2]);
+
+  glUniformMatrix4fv(shader_param_.matrix_projection_, 1, GL_FALSE,
+                     mat_vp.Ptr());
+  glUniformMatrix4fv(shader_param_.matrix_view_, 1, GL_FALSE, mat_view_.Ptr());
+  glUniform3f(shader_param_.light0_, 100.f, -200.f, -600.f);
+
+  glDrawElements(GL_TRIANGLES, num_indices_, GL_UNSIGNED_SHORT,
+                 BUFFER_OFFSET(0));
+
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+}
+
+bool TeapotRenderer::LoadShaders(SHADER_PARAMS* params, const char* strVsh,
+                                 const char* strFsh) {
+  GLuint program;
+  GLuint vert_shader, frag_shader;
+
+  // Create shader program
+  program = glCreateProgram();
+  LOGI("Created Shader %d", program);
+
+  // Create and compile vertex shader
+  if (!ndk_helper::shader::CompileShader(&vert_shader, GL_VERTEX_SHADER,
+                                         strVsh)) {
+    LOGI("Failed to compile vertex shader");
+    glDeleteProgram(program);
+    return false;
+  }
+
+  // Create and compile fragment shader
+  if (!ndk_helper::shader::CompileShader(&frag_shader, GL_FRAGMENT_SHADER,
+                                         strFsh)) {
+    LOGI("Failed to compile fragment shader");
+    glDeleteProgram(program);
+    return false;
+  }
+
+  // Attach vertex shader to program
+  glAttachShader(program, vert_shader);
+
+  // Attach fragment shader to program
+  glAttachShader(program, frag_shader);
+
+  // Bind attribute locations
+  // this needs to be done prior to linking
+  glBindAttribLocation(program, ATTRIB_VERTEX, "myVertex");
+  glBindAttribLocation(program, ATTRIB_NORMAL, "myNormal");
+  glBindAttribLocation(program, ATTRIB_UV, "myUV");
+
+  // Link program
+  if (!ndk_helper::shader::LinkProgram(program)) {
+    LOGI("Failed to link program: %d", program);
+
+    if (vert_shader) {
+      glDeleteShader(vert_shader);
+      vert_shader = 0;
+    }
+    if (frag_shader) {
+      glDeleteShader(frag_shader);
+      frag_shader = 0;
+    }
+    if (program) {
+      glDeleteProgram(program);
+    }
+
+    return false;
+  }
+
+  // Get uniform locations
+  params->matrix_projection_ = glGetUniformLocation(program, "uPMatrix");
+  params->matrix_view_ = glGetUniformLocation(program, "uMVMatrix");
+
+  params->light0_ = glGetUniformLocation(program, "vLight0");
+  params->material_diffuse_ = glGetUniformLocation(program, "vMaterialDiffuse");
+  params->material_ambient_ = glGetUniformLocation(program, "vMaterialAmbient");
+  params->material_specular_ =
+      glGetUniformLocation(program, "vMaterialSpecular");
+
+  // Release vertex and fragment shaders
+  if (vert_shader) glDeleteShader(vert_shader);
+  if (frag_shader) glDeleteShader(frag_shader);
+
+  params->program_ = program;
+  return true;
+}
+
+bool TeapotRenderer::Bind(ndk_helper::TapCamera* camera) {
+  camera_ = camera;
+  return true;
+}

Teapot/app/src/main/jni/TeapotRenderer.h

@@ -43,63 +43,61 @@
 
 #include "NDKHelper.h"
 
-#define BUFFER_OFFSET(i) ((char *)NULL + (i))
+#define BUFFER_OFFSET(i) ((char*)NULL + (i))
 
-struct TEAPOT_VERTEX
-{
-    float pos[3];
-    float normal[3];
+struct TEAPOT_VERTEX {
+  float pos[3];
+  float normal[3];
 };
 
-enum SHADER_ATTRIBUTES
-{
-    ATTRIB_VERTEX, ATTRIB_NORMAL, ATTRIB_UV,
+enum SHADER_ATTRIBUTES {
+  ATTRIB_VERTEX,
+  ATTRIB_NORMAL,
+  ATTRIB_UV,
 };
 
-struct SHADER_PARAMS
-{
-    GLuint program_;
-    GLuint light0_;
-    GLuint material_diffuse_;
-    GLuint material_ambient_;
-    GLuint material_specular_;
+struct SHADER_PARAMS {
+  GLuint program_;
+  GLuint light0_;
+  GLuint material_diffuse_;
+  GLuint material_ambient_;
+  GLuint material_specular_;
 
-    GLuint matrix_projection_;
-    GLuint matrix_view_;
+  GLuint matrix_projection_;
+  GLuint matrix_view_;
 };
 
-struct TEAPOT_MATERIALS
-{
-    float diffuse_color[3];
-    float specular_color[4];
-    float ambient_color[3];
+struct TEAPOT_MATERIALS {
+  float diffuse_color[3];
+  float specular_color[4];
+  float ambient_color[3];
 };
 
-class TeapotRenderer
-{
-    int32_t num_indices_;
-    int32_t num_vertices_;
-    GLuint ibo_;
-    GLuint vbo_;
+class TeapotRenderer {
+  int32_t num_indices_;
+  int32_t num_vertices_;
+  GLuint ibo_;
+  GLuint vbo_;
 
-    SHADER_PARAMS shader_param_;
-    bool LoadShaders( SHADER_PARAMS* params, const char* strVsh, const char* strFsh );
+  SHADER_PARAMS shader_param_;
+  bool LoadShaders(SHADER_PARAMS* params, const char* strVsh,
+                   const char* strFsh);
 
-    ndk_helper::Mat4 mat_projection_;
-    ndk_helper::Mat4 mat_view_;
-    ndk_helper::Mat4 mat_model_;
+  ndk_helper::Mat4 mat_projection_;
+  ndk_helper::Mat4 mat_view_;
+  ndk_helper::Mat4 mat_model_;
 
-    ndk_helper::TapCamera* camera_;
-public:
-    TeapotRenderer();
-    virtual ~TeapotRenderer();
-    void Init();
-    void Render();
-    void Update( float dTime );
-    bool Bind( ndk_helper::TapCamera* camera );
-    void Unload();
-    void UpdateViewport();
+  ndk_helper::TapCamera* camera_;
+
+ public:
+  TeapotRenderer();
+  virtual ~TeapotRenderer();
+  void Init();
+  void Render();
+  void Update(float dTime);
+  bool Bind(ndk_helper::TapCamera* camera);
+  void Unload();
+  void UpdateViewport();
 };
 
 #endif
-

Teapot/app/src/main/jni/ndk_helper/GLContext.cpp

@@ -0,0 +1,240 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//--------------------------------------------------------------------------------
+// GLContext.cpp
+//--------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------
+// includes
+//--------------------------------------------------------------------------------
+#include <unistd.h>
+#include "GLContext.h"
+#include "gl3stub.h"
+
+namespace ndk_helper {
+
+//--------------------------------------------------------------------------------
+// eGLContext
+//--------------------------------------------------------------------------------
+
+//--------------------------------------------------------------------------------
+// Ctor
+//--------------------------------------------------------------------------------
+GLContext::GLContext() {}
+
+void GLContext::InitGLES() {
+  if (gles_initialized_) return;
+  //
+  // Initialize OpenGL ES 3 if available
+  //
+  const char* versionStr = (const char*)glGetString(GL_VERSION);
+  if (strstr(versionStr, "OpenGL ES 3.") && gl3stubInit()) {
+    es3_supported_ = true;
+    gl_version_ = 3.0f;
+  } else {
+    gl_version_ = 2.0f;
+  }
+
+  gles_initialized_ = true;
+}
+
+//--------------------------------------------------------------------------------
+// Dtor
+//--------------------------------------------------------------------------------
+GLContext::~GLContext() { Terminate(); }
+
+bool GLContext::Init(ANativeWindow* window) {
+  if (egl_context_initialized_) return true;
+
+  //
+  // Initialize EGL
+  //
+  window_ = window;
+  InitEGLSurface();
+  InitEGLContext();
+  InitGLES();
+
+  egl_context_initialized_ = true;
+
+  return true;
+}
+
+bool GLContext::InitEGLSurface() {
+  display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  eglInitialize(display_, 0, 0);
+
+  /*
+   * Here specify the attributes of the desired configuration.
+   * Below, we select an EGLConfig with at least 8 bits per color
+   * component compatible with on-screen windows
+   */
+  const EGLint attribs[] = {
+      EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,  // Request opengl ES2.0
+      EGL_SURFACE_TYPE,    EGL_WINDOW_BIT,     EGL_BLUE_SIZE, 8,
+      EGL_GREEN_SIZE,      8,                  EGL_RED_SIZE,  8,
+      EGL_DEPTH_SIZE,      24,                 EGL_NONE};
+  color_size_ = 8;
+  depth_size_ = 24;
+
+  EGLint num_configs;
+  eglChooseConfig(display_, attribs, &config_, 1, &num_configs);
+
+  if (!num_configs) {
+    // Fall back to 16bit depth buffer
+    const EGLint attribs[] = {
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,  // Request opengl ES2.0
+        EGL_SURFACE_TYPE,    EGL_WINDOW_BIT,     EGL_BLUE_SIZE, 8,
+        EGL_GREEN_SIZE,      8,                  EGL_RED_SIZE,  8,
+        EGL_DEPTH_SIZE,      16,                 EGL_NONE};
+    eglChooseConfig(display_, attribs, &config_, 1, &num_configs);
+    depth_size_ = 16;
+  }
+
+  if (!num_configs) {
+    LOGW("Unable to retrieve EGL config");
+    return false;
+  }
+
+  surface_ = eglCreateWindowSurface(display_, config_, window_, NULL);
+  eglQuerySurface(display_, surface_, EGL_WIDTH, &screen_width_);
+  eglQuerySurface(display_, surface_, EGL_HEIGHT, &screen_height_);
+
+  return true;
+}
+
+bool GLContext::InitEGLContext() {
+  const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION,
+                                    2,  // Request opengl ES2.0
+                                    EGL_NONE};
+  context_ = eglCreateContext(display_, config_, NULL, context_attribs);
+
+  if (eglMakeCurrent(display_, surface_, surface_, context_) == EGL_FALSE) {
+    LOGW("Unable to eglMakeCurrent");
+    return false;
+  }
+
+  context_valid_ = true;
+  return true;
+}
+
+EGLint GLContext::Swap() {
+  bool b = eglSwapBuffers(display_, surface_);
+  if (!b) {
+    EGLint err = eglGetError();
+    if (err == EGL_BAD_SURFACE) {
+      // Recreate surface
+      InitEGLSurface();
+      return EGL_SUCCESS;  // Still consider glContext is valid
+    } else if (err == EGL_CONTEXT_LOST || err == EGL_BAD_CONTEXT) {
+      // Context has been lost!!
+      context_valid_ = false;
+      Terminate();
+      InitEGLContext();
+    }
+    return err;
+  }
+  return EGL_SUCCESS;
+}
+
+void GLContext::Terminate() {
+  if (display_ != EGL_NO_DISPLAY) {
+    eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    if (context_ != EGL_NO_CONTEXT) {
+      eglDestroyContext(display_, context_);
+    }
+
+    if (surface_ != EGL_NO_SURFACE) {
+      eglDestroySurface(display_, surface_);
+    }
+    eglTerminate(display_);
+  }
+
+  display_ = EGL_NO_DISPLAY;
+  context_ = EGL_NO_CONTEXT;
+  surface_ = EGL_NO_SURFACE;
+  context_valid_ = false;
+}
+
+EGLint GLContext::Resume(ANativeWindow* window) {
+  if (egl_context_initialized_ == false) {
+    Init(window);
+    return EGL_SUCCESS;
+  }
+
+  int32_t original_widhth = screen_width_;
+  int32_t original_height = screen_height_;
+
+  // Create surface
+  window_ = window;
+  surface_ = eglCreateWindowSurface(display_, config_, window_, NULL);
+  eglQuerySurface(display_, surface_, EGL_WIDTH, &screen_width_);
+  eglQuerySurface(display_, surface_, EGL_HEIGHT, &screen_height_);
+
+  if (screen_width_ != original_widhth || screen_height_ != original_height) {
+    // Screen resized
+    LOGI("Screen resized");
+  }
+
+  if (eglMakeCurrent(display_, surface_, surface_, context_) == EGL_TRUE)
+    return EGL_SUCCESS;
+
+  EGLint err = eglGetError();
+  LOGW("Unable to eglMakeCurrent %d", err);
+
+  if (err == EGL_CONTEXT_LOST) {
+    // Recreate context
+    LOGI("Re-creating egl context");
+    InitEGLContext();
+  } else {
+    // Recreate surface
+    Terminate();
+    InitEGLSurface();
+    InitEGLContext();
+  }
+
+  return err;
+}
+
+void GLContext::Suspend() {
+  if (surface_ != EGL_NO_SURFACE) {
+    eglDestroySurface(display_, surface_);
+    surface_ = EGL_NO_SURFACE;
+  }
+}
+
+bool GLContext::Invalidate() {
+  Terminate();
+
+  egl_context_initialized_ = false;
+  return true;
+}
+
+bool GLContext::CheckExtension(const char* extension) {
+  if (extension == NULL) return false;
+
+  std::string extensions = std::string((char*)glGetString(GL_EXTENSIONS));
+  std::string str = std::string(extension);
+  str.append(" ");
+
+  size_t pos = 0;
+  if (extensions.find(extension, pos) != std::string::npos) {
+    return true;
+  }
+
+  return false;
+}
+
+}  // namespace ndkHelper

Teapot/app/src/main/jni/ndk_helper/GLContext.h

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//--------------------------------------------------------------------------------
+// GLContext.h
+//--------------------------------------------------------------------------------
+#ifndef GLCONTEXT_H_
+#define GLCONTEXT_H_
+
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+#include <android/log.h>
+
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+//--------------------------------------------------------------------------------
+// Constants
+//--------------------------------------------------------------------------------
+
+//--------------------------------------------------------------------------------
+// Class
+//--------------------------------------------------------------------------------
+
+/******************************************************************
+ * OpenGL context handler
+ * The class handles OpenGL and EGL context based on Android activity life cycle
+ * The caller needs to call corresponding methods for each activity life cycle
+ *events as it's done in sample codes.
+ *
+ * Also the class initializes OpenGL ES3 when the compatible driver is installed
+ *in the device.
+ * getGLVersion() returns 3.0~ when the device supports OpenGLES3.0
+ *
+ * Thread safety: OpenGL context is expecting used within dedicated single
+ *thread,
+ * thus GLContext class is not designed as a thread-safe
+ */
+class GLContext {
+ private:
+  // EGL configurations
+  ANativeWindow* window_;
+  EGLDisplay display_ {EGL_NO_DISPLAY};
+  EGLSurface surface_ {EGL_NO_SURFACE};
+  EGLContext context_ {EGL_NO_CONTEXT};
+  EGLConfig config_ {nullptr};
+
+  // Screen parameters
+  int32_t screen_width_ {0};
+  int32_t screen_height_ {0};
+  int32_t color_size_;
+  int32_t depth_size_;
+
+  // Flags
+  bool gles_initialized_ {false};
+  bool egl_context_initialized_ {false};
+  bool es3_supported_ {false};
+  float gl_version_;
+  bool context_valid_ {false};
+
+  void InitGLES();
+  void Terminate();
+  bool InitEGLSurface();
+  bool InitEGLContext();
+
+  GLContext(GLContext const&);
+  void operator=(GLContext const&);
+  GLContext();
+  virtual ~GLContext();
+
+ public:
+  static GLContext* GetInstance() {
+    // Singleton
+    static GLContext instance;
+
+    return &instance;
+  }
+
+  bool Init(ANativeWindow* window);
+  EGLint Swap();
+  bool Invalidate();
+
+  void Suspend();
+  EGLint Resume(ANativeWindow* window);
+
+  int32_t GetScreenWidth() { return screen_width_; }
+  int32_t GetScreenHeight() { return screen_height_; }
+
+  int32_t GetBufferColorSize() { return color_size_; }
+  int32_t GetBufferDepthSize() { return depth_size_; }
+  float GetGLVersion() { return gl_version_; }
+  bool CheckExtension(const char* extension);
+};
+
+}  // namespace ndkHelper
+
+#endif /* GLCONTEXT_H_ */

Teapot/app/src/main/jni/ndk_helper/JNIHelper.cpp

@@ -0,0 +1,365 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 <EGL/egl.h>
+#include <GLES2/gl2.h>
+#include <fstream>
+#include <iostream>
+
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+#define CLASS_NAME "android/app/NativeActivity"
+
+//---------------------------------------------------------------------------
+// JNI Helper functions
+//---------------------------------------------------------------------------
+
+//---------------------------------------------------------------------------
+// Singleton
+//---------------------------------------------------------------------------
+JNIHelper* JNIHelper::GetInstance() {
+  static JNIHelper helper;
+  return &helper;
+}
+
+//---------------------------------------------------------------------------
+// Ctor
+//---------------------------------------------------------------------------
+JNIHelper::JNIHelper() { pthread_mutex_init(&mutex_, NULL); }
+
+//---------------------------------------------------------------------------
+// Dtor
+//---------------------------------------------------------------------------
+JNIHelper::~JNIHelper() {
+  pthread_mutex_lock(&mutex_);
+
+  JNIEnv* env;
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  env->DeleteGlobalRef(jni_helper_java_ref_);
+  env->DeleteGlobalRef(jni_helper_java_class_);
+
+  activity_->vm->DetachCurrentThread();
+
+  pthread_mutex_destroy(&mutex_);
+}
+
+//---------------------------------------------------------------------------
+// Init
+//---------------------------------------------------------------------------
+void JNIHelper::Init(ANativeActivity* activity, const char* helper_class_name) {
+  JNIHelper& helper = *GetInstance();
+  pthread_mutex_lock(&helper.mutex_);
+
+  helper.activity_ = activity;
+
+  JNIEnv* env;
+  helper.activity_->vm->AttachCurrentThread(&env, NULL);
+
+  // Retrieve app name
+  jclass android_content_Context = env->GetObjectClass(helper.activity_->clazz);
+  jmethodID midGetPackageName = env->GetMethodID(
+      android_content_Context, "getPackageName", "()Ljava/lang/String;");
+
+  jstring packageName = (jstring)env->CallObjectMethod(helper.activity_->clazz,
+                                                       midGetPackageName);
+  const char* appname = env->GetStringUTFChars(packageName, NULL);
+  helper.app_name_ = std::string(appname);
+
+  jclass cls = helper.RetrieveClass(env, helper_class_name);
+  helper.jni_helper_java_class_ = (jclass)env->NewGlobalRef(cls);
+
+  jmethodID constructor =
+      env->GetMethodID(helper.jni_helper_java_class_, "<init>", "()V");
+  helper.jni_helper_java_ref_ =
+      env->NewObject(helper.jni_helper_java_class_, constructor);
+  helper.jni_helper_java_ref_ = env->NewGlobalRef(helper.jni_helper_java_ref_);
+
+  env->ReleaseStringUTFChars(packageName, appname);
+  helper.activity_->vm->DetachCurrentThread();
+
+  pthread_mutex_unlock(&helper.mutex_);
+}
+
+//---------------------------------------------------------------------------
+// readFile
+//---------------------------------------------------------------------------
+bool JNIHelper::ReadFile(const char* fileName,
+                         std::vector<uint8_t>* buffer_ref) {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized.Call init() to initialize the "
+        "helper");
+    return false;
+  }
+
+  // First, try reading from externalFileDir;
+  JNIEnv* env;
+
+  pthread_mutex_lock(&mutex_);
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  jstring str_path = GetExternalFilesDirJString(env);
+  const char* path = env->GetStringUTFChars(str_path, NULL);
+  std::string s(path);
+
+  if (fileName[0] != '/') {
+    s.append("/");
+  }
+  s.append(fileName);
+  std::ifstream f(s.c_str(), std::ios::binary);
+
+  env->ReleaseStringUTFChars(str_path, path);
+  env->DeleteLocalRef(str_path);
+  activity_->vm->DetachCurrentThread();
+
+  if (f) {
+    LOGI("reading:%s", s.c_str());
+    f.seekg(0, std::ifstream::end);
+    int32_t fileSize = f.tellg();
+    f.seekg(0, std::ifstream::beg);
+    buffer_ref->reserve(fileSize);
+    buffer_ref->assign(std::istreambuf_iterator<char>(f),
+                       std::istreambuf_iterator<char>());
+    f.close();
+    pthread_mutex_unlock(&mutex_);
+    return true;
+  } else {
+    // Fallback to assetManager
+    AAssetManager* assetManager = activity_->assetManager;
+    AAsset* assetFile =
+        AAssetManager_open(assetManager, fileName, AASSET_MODE_BUFFER);
+    if (!assetFile) {
+      pthread_mutex_unlock(&mutex_);
+      return false;
+    }
+    uint8_t* data = (uint8_t*)AAsset_getBuffer(assetFile);
+    int32_t size = AAsset_getLength(assetFile);
+    if (data == NULL) {
+      AAsset_close(assetFile);
+
+      LOGI("Failed to load:%s", fileName);
+      pthread_mutex_unlock(&mutex_);
+      return false;
+    }
+
+    buffer_ref->reserve(size);
+    buffer_ref->assign(data, data + size);
+
+    AAsset_close(assetFile);
+    pthread_mutex_unlock(&mutex_);
+    return true;
+  }
+}
+
+std::string JNIHelper::GetExternalFilesDir() {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return std::string("");
+  }
+
+  pthread_mutex_lock(&mutex_);
+
+  // First, try reading from externalFileDir;
+  JNIEnv* env;
+
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  jstring strPath = GetExternalFilesDirJString(env);
+  const char* path = env->GetStringUTFChars(strPath, NULL);
+  std::string s(path);
+
+  env->ReleaseStringUTFChars(strPath, path);
+  env->DeleteLocalRef(strPath);
+  activity_->vm->DetachCurrentThread();
+
+  pthread_mutex_unlock(&mutex_);
+  return s;
+}
+
+uint32_t JNIHelper::LoadTexture(const char* file_name) {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return 0;
+  }
+
+  JNIEnv* env;
+  jmethodID mid;
+
+  pthread_mutex_lock(&mutex_);
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  jstring name = env->NewStringUTF(file_name);
+
+  GLuint tex;
+  glGenTextures(1, &tex);
+  glBindTexture(GL_TEXTURE_2D, tex);
+
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                  GL_LINEAR_MIPMAP_NEAREST);
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+  mid = env->GetMethodID(jni_helper_java_class_, "loadTexture",
+                         "(Ljava/lang/String;)Z");
+  jboolean ret = env->CallBooleanMethod(jni_helper_java_ref_, mid, name);
+  if (!ret) {
+    glDeleteTextures(1, &tex);
+    tex = -1;
+    LOGI("Texture load failed %s", file_name);
+  }
+
+  // Generate mipmap
+  glGenerateMipmap(GL_TEXTURE_2D);
+
+  env->DeleteLocalRef(name);
+  activity_->vm->DetachCurrentThread();
+  pthread_mutex_unlock(&mutex_);
+
+  return tex;
+}
+
+std::string JNIHelper::ConvertString(const char* str, const char* encode) {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return std::string("");
+  }
+
+  JNIEnv* env;
+
+  pthread_mutex_lock(&mutex_);
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  int32_t iLength = strlen((const char*)str);
+
+  jbyteArray array = env->NewByteArray(iLength);
+  env->SetByteArrayRegion(array, 0, iLength, (const signed char*)str);
+
+  jstring strEncode = env->NewStringUTF(encode);
+
+  jclass cls = env->FindClass("java/lang/String");
+  jmethodID ctor = env->GetMethodID(cls, "<init>", "([BLjava/lang/String;)V");
+  jstring object = (jstring)env->NewObject(cls, ctor, array, strEncode);
+
+  const char* cparam = env->GetStringUTFChars(object, NULL);
+
+  std::string s = std::string(cparam);
+
+  env->ReleaseStringUTFChars(object, cparam);
+  env->DeleteLocalRef(strEncode);
+  env->DeleteLocalRef(object);
+  activity_->vm->DetachCurrentThread();
+  pthread_mutex_unlock(&mutex_);
+
+  return s;
+}
+
+//---------------------------------------------------------------------------
+// Audio helpers
+//---------------------------------------------------------------------------
+int32_t JNIHelper::GetNativeAudioBufferSize() {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return 0;
+  }
+
+  JNIEnv* env;
+  jmethodID mid;
+
+  pthread_mutex_lock(&mutex_);
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  mid = env->GetMethodID(jni_helper_java_class_, "getNativeAudioBufferSize",
+                         "()I");
+  int32_t i = env->CallIntMethod(jni_helper_java_ref_, mid);
+  activity_->vm->DetachCurrentThread();
+  pthread_mutex_unlock(&mutex_);
+
+  return i;
+}
+
+int32_t JNIHelper::GetNativeAudioSampleRate() {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return 0;
+  }
+
+  JNIEnv* env;
+  jmethodID mid;
+
+  pthread_mutex_lock(&mutex_);
+  activity_->vm->AttachCurrentThread(&env, NULL);
+
+  mid = env->GetMethodID(jni_helper_java_class_, "getNativeAudioSampleRate",
+                         "()I");
+  int32_t i = env->CallIntMethod(jni_helper_java_ref_, mid);
+  activity_->vm->DetachCurrentThread();
+  pthread_mutex_unlock(&mutex_);
+
+  return i;
+}
+
+//---------------------------------------------------------------------------
+// Misc implementations
+//---------------------------------------------------------------------------
+jclass JNIHelper::RetrieveClass(JNIEnv* jni, const char* class_name) {
+  jclass activity_class = jni->FindClass(CLASS_NAME);
+  jmethodID get_class_loader = jni->GetMethodID(
+      activity_class, "getClassLoader", "()Ljava/lang/ClassLoader;");
+  jobject cls = jni->CallObjectMethod(activity_->clazz, get_class_loader);
+  jclass class_loader = jni->FindClass("java/lang/ClassLoader");
+  jmethodID find_class = jni->GetMethodID(
+      class_loader, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
+
+  jstring str_class_name = jni->NewStringUTF(class_name);
+  jclass class_retrieved =
+      (jclass)jni->CallObjectMethod(cls, find_class, str_class_name);
+  jni->DeleteLocalRef(str_class_name);
+  return class_retrieved;
+}
+
+jstring JNIHelper::GetExternalFilesDirJString(JNIEnv* env) {
+  if (activity_ == NULL) {
+    LOGI(
+        "JNIHelper has not been initialized. Call init() to initialize the "
+        "helper");
+    return NULL;
+  }
+
+  // Invoking getExternalFilesDir() java API
+  jclass cls_Env = env->FindClass(CLASS_NAME);
+  jmethodID mid = env->GetMethodID(cls_Env, "getExternalFilesDir",
+                                   "(Ljava/lang/String;)Ljava/io/File;");
+  jobject obj_File = env->CallObjectMethod(activity_->clazz, mid, NULL);
+  jclass cls_File = env->FindClass("java/io/File");
+  jmethodID mid_getPath =
+      env->GetMethodID(cls_File, "getPath", "()Ljava/lang/String;");
+  jstring obj_Path = (jstring)env->CallObjectMethod(obj_File, mid_getPath);
+
+  return obj_Path;
+}
+
+}  // namespace ndkHelper

Teapot/app/src/main/jni/ndk_helper/JNIHelper.h

@@ -0,0 +1,183 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <jni.h>
+#include <vector>
+#include <string>
+
+#include <android/log.h>
+#include <android_native_app_glue.h>
+
+#define LOGI(...)                                                           \
+  ((void)__android_log_print(                                               \
+      ANDROID_LOG_INFO, ndk_helper::JNIHelper::GetInstance()->GetAppName(), \
+      __VA_ARGS__))
+#define LOGW(...)                                                           \
+  ((void)__android_log_print(                                               \
+      ANDROID_LOG_WARN, ndk_helper::JNIHelper::GetInstance()->GetAppName(), \
+      __VA_ARGS__))
+#define LOGE(...)                                                            \
+  ((void)__android_log_print(                                                \
+      ANDROID_LOG_ERROR, ndk_helper::JNIHelper::GetInstance()->GetAppName(), \
+      __VA_ARGS__))
+
+namespace ndk_helper {
+
+/******************************************************************
+ * Helper functions for JNI calls
+ * This class wraps JNI calls and provides handy interface calling commonly used
+ *features
+ * in Java SDK.
+ * Such as
+ * - loading graphics files (e.g. PNG, JPG)
+ * - character code conversion
+ * - retrieving system properties which only supported in Java SDK
+ *
+ * NOTE: To use this class, add NDKHelper.java as a corresponding helpers in
+ *Java code
+ */
+class JNIHelper {
+ private:
+  std::string app_name_;
+
+  ANativeActivity* activity_;
+  jobject jni_helper_java_ref_;
+  jclass jni_helper_java_class_;
+
+  // mutex for synchronization
+  // This class uses singleton pattern and can be invoked from multiple threads,
+  // each methods locks the mutex for a thread safety
+  mutable pthread_mutex_t mutex_;
+
+  jstring GetExternalFilesDirJString(JNIEnv* env);
+  jclass RetrieveClass(JNIEnv* jni, const char* class_name);
+
+  JNIHelper();
+  ~JNIHelper();
+  JNIHelper(const JNIHelper& rhs);
+  JNIHelper& operator=(const JNIHelper& rhs);
+
+ public:
+  /*
+   * To load your own Java classes, JNIHelper requires to be initialized with a
+   *ANativeActivity handle.
+   * This methods need to be called before any call to the helper class.
+   * Static member of the class
+   *
+   * arguments:
+   * in: activity, pointer to ANativeActivity. Used internally to set up JNI
+   *environment
+   * in: helper_class_name, pointer to Java side helper class name. (e.g.
+   *"com/sample/helper/NDKHelper" in samples )
+   */
+  static void Init(ANativeActivity* activity, const char* helper_class_name);
+
+  /*
+   * Retrieve the singleton object of the helper.
+   * Static member of the class
+
+   * Methods in the class are designed as thread safe.
+   */
+  static JNIHelper* GetInstance();
+
+  /*
+   * Read a file from a strorage.
+   * First, the method tries to read the file from an external storage.
+   * If it fails to read, it falls back to use assset manager and try to read
+   *the file from APK asset.
+   *
+   * arguments:
+   * in: file_name, file name to read
+   * out: buffer_ref, pointer to a vector buffer to read a file.
+   *      when the call succeeded, the buffer includes contents of specified
+   *file
+   *      when the call failed, contents of the buffer remains same
+   * return:
+   * true when file read succeeded
+   * false when it failed to read the file
+   */
+  bool ReadFile(const char* file_name, std::vector<uint8_t>* buffer_ref);
+
+  /*
+   * Load and create OpenGL texture from given file name.
+   * The method invokes BitmapFactory in Java so it can read jpeg/png formatted
+   *files
+   *
+   * The methods creates mip-map and set texture parameters like this,
+   * glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+   *GL_LINEAR_MIPMAP_NEAREST );
+   * glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+   * glGenerateMipmap( GL_TEXTURE_2D );
+   *
+   * arguments:
+   * in: file_name, file name to read, PNG&JPG is supported
+   * return:
+   * OpenGL texture name when the call succeeded
+   * When it failed to load the texture, it returns -1
+   */
+  uint32_t LoadTexture(const char* file_name);
+
+  /*
+   * Convert string from character code other than UTF-8
+   *
+   * arguments:
+   *  in: str, pointer to a string which is encoded other than UTF-8
+   *  in: encoding, pointer to a character encoding string.
+   *  The encoding string can be any valid java.nio.charset.Charset name
+   *  e.g. "UTF-16", "Shift_JIS"
+   * return: converted input string as an UTF-8 std::string
+   */
+  std::string ConvertString(const char* str, const char* encode);
+  /*
+   * Retrieve external file directory through JNI call
+   *
+   * return: std::string containing external file diretory
+   */
+  std::string GetExternalFilesDir();
+
+  /*
+   * Audio helper
+   * Retrieves native audio buffer size which is required to achieve low latency
+   *audio
+   *
+   * return: Native audio buffer size which is a hint to achieve low latency
+   *audio
+   * If the API is not supported (API level < 17), it returns 0
+   */
+  int32_t GetNativeAudioBufferSize();
+
+  /*
+   * Audio helper
+   * Retrieves native audio sample rate which is required to achieve low latency
+   *audio
+   *
+   * return: Native audio sample rate which is a hint to achieve low latency
+   *audio
+   */
+  int32_t GetNativeAudioSampleRate();
+
+  /*
+   * Retrieves application bundle name
+   *
+   * return: pointer to an app name string
+   *
+   */
+  const char* GetAppName() { return app_name_.c_str(); }
+};
+
+}  // namespace ndkHelper

Teapot/app/src/main/jni/ndk_helper/NDKHelper.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 _NDKSUPPORT_H
+#define _NDKSUPPORT_H
+
+/******************************************************************
+ * NDK support helpers
+ * Utility module to provide misc functionalities that is used widely in native
+ *applications,
+ * such as gesture detection, jni bridge, openGL context etc.
+ *
+ * The purpose of this module is,
+ * - Provide best practices using NDK
+ * - Provide handy utility functions for NDK development
+ * - Make NDK samples more simpler and readable
+ */
+#include "gl3stub.h"    //GLES3 stubs
+#include "GLContext.h"  //EGL & OpenGL manager
+#include "shader.h"     //Shader compiler support
+#include "vecmath.h"  //Vector math support, C++ implementation n current version
+#include "tapCamera.h"        //Tap/Pinch camera control
+#include "JNIHelper.h"        //JNI support
+#include "gestureDetector.h"  //Tap/Doubletap/Pinch detector
+#include "perfMonitor.h"      //FPS counter
+#include "interpolator.h"     //Interpolator
+#endif

Teapot/app/src/main/jni/ndk_helper/gestureDetector.cpp

@@ -0,0 +1,296 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 "gestureDetector.h"
+
+//--------------------------------------------------------------------------------
+// gestureDetector.cpp
+//--------------------------------------------------------------------------------
+namespace ndk_helper {
+
+//--------------------------------------------------------------------------------
+// includes
+//--------------------------------------------------------------------------------
+
+//--------------------------------------------------------------------------------
+// GestureDetector
+//--------------------------------------------------------------------------------
+GestureDetector::GestureDetector() { dp_factor_ = 1.f; }
+
+void GestureDetector::SetConfiguration(AConfiguration* config) {
+  dp_factor_ = 160.f / AConfiguration_getDensity(config);
+}
+
+//--------------------------------------------------------------------------------
+// TapDetector
+//--------------------------------------------------------------------------------
+GESTURE_STATE TapDetector::Detect(const AInputEvent* motion_event) {
+  if (AMotionEvent_getPointerCount(motion_event) > 1) {
+    // Only support single touch
+    return false;
+  }
+
+  int32_t action = AMotionEvent_getAction(motion_event);
+  unsigned int flags = action & AMOTION_EVENT_ACTION_MASK;
+  switch (flags) {
+    case AMOTION_EVENT_ACTION_DOWN:
+      down_pointer_id_ = AMotionEvent_getPointerId(motion_event, 0);
+      down_x_ = AMotionEvent_getX(motion_event, 0);
+      down_y_ = AMotionEvent_getY(motion_event, 0);
+      break;
+    case AMOTION_EVENT_ACTION_UP: {
+      int64_t eventTime = AMotionEvent_getEventTime(motion_event);
+      int64_t downTime = AMotionEvent_getDownTime(motion_event);
+      if (eventTime - downTime <= TAP_TIMEOUT) {
+        if (down_pointer_id_ == AMotionEvent_getPointerId(motion_event, 0)) {
+          float x = AMotionEvent_getX(motion_event, 0) - down_x_;
+          float y = AMotionEvent_getY(motion_event, 0) - down_y_;
+          if (x * x + y * y < TOUCH_SLOP * TOUCH_SLOP * dp_factor_) {
+            LOGI("TapDetector: Tap detected");
+            return GESTURE_STATE_ACTION;
+          }
+        }
+      }
+      break;
+    }
+  }
+  return GESTURE_STATE_NONE;
+}
+
+//--------------------------------------------------------------------------------
+// DoubletapDetector
+//--------------------------------------------------------------------------------
+GESTURE_STATE DoubletapDetector::Detect(const AInputEvent* motion_event) {
+  if (AMotionEvent_getPointerCount(motion_event) > 1) {
+    // Only support single double tap
+    return false;
+  }
+
+  bool tap_detected = tap_detector_.Detect(motion_event);
+
+  int32_t action = AMotionEvent_getAction(motion_event);
+  unsigned int flags = action & AMOTION_EVENT_ACTION_MASK;
+  switch (flags) {
+    case AMOTION_EVENT_ACTION_DOWN: {
+      int64_t eventTime = AMotionEvent_getEventTime(motion_event);
+      if (eventTime - last_tap_time_ <= DOUBLE_TAP_TIMEOUT) {
+        float x = AMotionEvent_getX(motion_event, 0) - last_tap_x_;
+        float y = AMotionEvent_getY(motion_event, 0) - last_tap_y_;
+        if (x * x + y * y < DOUBLE_TAP_SLOP * DOUBLE_TAP_SLOP * dp_factor_) {
+          LOGI("DoubletapDetector: Doubletap detected");
+          return GESTURE_STATE_ACTION;
+        }
+      }
+      break;
+    }
+    case AMOTION_EVENT_ACTION_UP:
+      if (tap_detected) {
+        last_tap_time_ = AMotionEvent_getEventTime(motion_event);
+        last_tap_x_ = AMotionEvent_getX(motion_event, 0);
+        last_tap_y_ = AMotionEvent_getY(motion_event, 0);
+      }
+      break;
+  }
+  return GESTURE_STATE_NONE;
+}
+
+void DoubletapDetector::SetConfiguration(AConfiguration* config) {
+  dp_factor_ = 160.f / AConfiguration_getDensity(config);
+  tap_detector_.SetConfiguration(config);
+}
+
+//--------------------------------------------------------------------------------
+// PinchDetector
+//--------------------------------------------------------------------------------
+
+int32_t PinchDetector::FindIndex(const AInputEvent* event, int32_t id) {
+  int32_t count = AMotionEvent_getPointerCount(event);
+  for (auto i = 0; i < count; ++i) {
+    if (id == AMotionEvent_getPointerId(event, i)) return i;
+  }
+  return -1;
+}
+
+GESTURE_STATE PinchDetector::Detect(const AInputEvent* event) {
+  GESTURE_STATE ret = GESTURE_STATE_NONE;
+  int32_t action = AMotionEvent_getAction(event);
+  uint32_t flags = action & AMOTION_EVENT_ACTION_MASK;
+  event_ = event;
+
+  int32_t count = AMotionEvent_getPointerCount(event);
+  switch (flags) {
+    case AMOTION_EVENT_ACTION_DOWN:
+      vec_pointers_.push_back(AMotionEvent_getPointerId(event, 0));
+      break;
+    case AMOTION_EVENT_ACTION_POINTER_DOWN: {
+      int32_t iIndex = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
+                       AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
+      vec_pointers_.push_back(AMotionEvent_getPointerId(event, iIndex));
+      if (count == 2) {
+        // Start new pinch
+        ret = GESTURE_STATE_START;
+      }
+    } break;
+    case AMOTION_EVENT_ACTION_UP:
+      vec_pointers_.pop_back();
+      break;
+    case AMOTION_EVENT_ACTION_POINTER_UP: {
+      int32_t index = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
+                      AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
+      int32_t released_pointer_id = AMotionEvent_getPointerId(event, index);
+
+      std::vector<int32_t>::iterator it = vec_pointers_.begin();
+      std::vector<int32_t>::iterator it_end = vec_pointers_.end();
+      int32_t i = 0;
+      for (; it != it_end; ++it, ++i) {
+        if (*it == released_pointer_id) {
+          vec_pointers_.erase(it);
+          break;
+        }
+      }
+
+      if (i <= 1) {
+        // Reset pinch or drag
+        if (count != 2) {
+          // Start new pinch
+          ret = GESTURE_STATE_START | GESTURE_STATE_END;
+        }
+      }
+    } break;
+    case AMOTION_EVENT_ACTION_MOVE:
+      switch (count) {
+        case 1:
+          break;
+        default:
+          // Multi touch
+          ret = GESTURE_STATE_MOVE;
+          break;
+      }
+      break;
+    case AMOTION_EVENT_ACTION_CANCEL:
+      break;
+  }
+
+  return ret;
+}
+
+bool PinchDetector::GetPointers(Vec2& v1, Vec2& v2) {
+  if (vec_pointers_.size() < 2) return false;
+
+  int32_t index = FindIndex(event_, vec_pointers_[0]);
+  if (index == -1) return false;
+
+  float x = AMotionEvent_getX(event_, index);
+  float y = AMotionEvent_getY(event_, index);
+
+  index = FindIndex(event_, vec_pointers_[1]);
+  if (index == -1) return false;
+
+  float x2 = AMotionEvent_getX(event_, index);
+  float y2 = AMotionEvent_getY(event_, index);
+
+  v1 = Vec2(x, y);
+  v2 = Vec2(x2, y2);
+
+  return true;
+}
+
+//--------------------------------------------------------------------------------
+// DragDetector
+//--------------------------------------------------------------------------------
+
+int32_t DragDetector::FindIndex(const AInputEvent* event, int32_t id) {
+  int32_t count = AMotionEvent_getPointerCount(event);
+  for (auto i = 0; i < count; ++i) {
+    if (id == AMotionEvent_getPointerId(event, i)) return i;
+  }
+  return -1;
+}
+
+GESTURE_STATE DragDetector::Detect(const AInputEvent* event) {
+  GESTURE_STATE ret = GESTURE_STATE_NONE;
+  int32_t action = AMotionEvent_getAction(event);
+  int32_t index = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
+                  AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
+  uint32_t flags = action & AMOTION_EVENT_ACTION_MASK;
+  event_ = event;
+
+  int32_t count = AMotionEvent_getPointerCount(event);
+  switch (flags) {
+    case AMOTION_EVENT_ACTION_DOWN:
+      vec_pointers_.push_back(AMotionEvent_getPointerId(event, 0));
+      ret = GESTURE_STATE_START;
+      break;
+    case AMOTION_EVENT_ACTION_POINTER_DOWN:
+      vec_pointers_.push_back(AMotionEvent_getPointerId(event, index));
+      break;
+    case AMOTION_EVENT_ACTION_UP:
+      vec_pointers_.pop_back();
+      ret = GESTURE_STATE_END;
+      break;
+    case AMOTION_EVENT_ACTION_POINTER_UP: {
+      int32_t released_pointer_id = AMotionEvent_getPointerId(event, index);
+
+      std::vector<int32_t>::iterator it = vec_pointers_.begin();
+      std::vector<int32_t>::iterator it_end = vec_pointers_.end();
+      int32_t i = 0;
+      for (; it != it_end; ++it, ++i) {
+        if (*it == released_pointer_id) {
+          vec_pointers_.erase(it);
+          break;
+        }
+      }
+
+      if (i <= 1) {
+        // Reset pinch or drag
+        if (count == 2) {
+          ret = GESTURE_STATE_START;
+        }
+      }
+      break;
+    }
+    case AMOTION_EVENT_ACTION_MOVE:
+      switch (count) {
+        case 1:
+          // Drag
+          ret = GESTURE_STATE_MOVE;
+          break;
+        default:
+          break;
+      }
+      break;
+    case AMOTION_EVENT_ACTION_CANCEL:
+      break;
+  }
+
+  return ret;
+}
+
+bool DragDetector::GetPointer(Vec2& v) {
+  if (vec_pointers_.size() < 1) return false;
+
+  int32_t iIndex = FindIndex(event_, vec_pointers_[0]);
+  if (iIndex == -1) return false;
+
+  float x = AMotionEvent_getX(event_, iIndex);
+  float y = AMotionEvent_getY(event_, iIndex);
+
+  v = Vec2(x, y);
+
+  return true;
+}
+
+}  // namespace ndkHelper

Teapot/app/src/main/jni/ndk_helper/gestureDetector.h

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//--------------------------------------------------------------------------------
+// gestureDetector.h
+//--------------------------------------------------------------------------------
+#ifndef GESTUREDETECTOR_H_
+#define GESTUREDETECTOR_H_
+
+#include <vector>
+
+#include <android/sensor.h>
+#include <android/log.h>
+#include <android_native_app_glue.h>
+#include <android/native_window_jni.h>
+#include "JNIHelper.h"
+#include "vecmath.h"
+
+namespace ndk_helper {
+//--------------------------------------------------------------------------------
+// Constants
+//--------------------------------------------------------------------------------
+const int32_t DOUBLE_TAP_TIMEOUT = 300 * 1000000;
+const int32_t TAP_TIMEOUT = 180 * 1000000;
+const int32_t DOUBLE_TAP_SLOP = 100;
+const int32_t TOUCH_SLOP = 8;
+
+enum {
+  GESTURE_STATE_NONE = 0,
+  GESTURE_STATE_START = 1,
+  GESTURE_STATE_MOVE = 2,
+  GESTURE_STATE_END = 4,
+  GESTURE_STATE_ACTION = (GESTURE_STATE_START | GESTURE_STATE_END),
+};
+typedef int32_t GESTURE_STATE;
+
+/******************************************************************
+ * Base class of Gesture Detectors
+ * GestureDetectors handles input events and detect gestures
+ * Note that different detectors may detect gestures with an event at
+ * same time. The caller needs to manage gesture priority accordingly
+ *
+ */
+class GestureDetector {
+ protected:
+  float dp_factor_;
+
+ public:
+  GestureDetector();
+  virtual ~GestureDetector() {}
+  virtual void SetConfiguration(AConfiguration* config);
+
+  virtual GESTURE_STATE Detect(const AInputEvent* motion_event) = 0;
+};
+
+/******************************************************************
+ * Tap gesture detector
+ * Returns GESTURE_STATE_ACTION when a tap gesture is detected
+ *
+ */
+class TapDetector : public GestureDetector {
+ private:
+  int32_t down_pointer_id_;
+  float down_x_;
+  float down_y_;
+
+ public:
+  TapDetector() {}
+  virtual ~TapDetector() {}
+  virtual GESTURE_STATE Detect(const AInputEvent* motion_event);
+};
+
+/******************************************************************
+ * Pinch gesture detector
+ * Returns GESTURE_STATE_ACTION when a double-tap gesture is detected
+ *
+ */
+class DoubletapDetector : public GestureDetector {
+ private:
+  TapDetector tap_detector_;
+  int64_t last_tap_time_;
+  float last_tap_x_;
+  float last_tap_y_;
+
+ public:
+  DoubletapDetector() {}
+  virtual ~DoubletapDetector() {}
+  virtual GESTURE_STATE Detect(const AInputEvent* motion_event);
+  virtual void SetConfiguration(AConfiguration* config);
+};
+
+/******************************************************************
+ * Double gesture detector
+ * Returns pinch gesture state when a pinch gesture is detected
+ * The class handles multiple touches more than 2
+ * When the finger 1,2,3 are tapped and then finger 1 is released,
+ * the detector start new pinch gesture with finger 2 & 3.
+ */
+class PinchDetector : public GestureDetector {
+ private:
+  int32_t FindIndex(const AInputEvent* event, int32_t id);
+  const AInputEvent* event_;
+  std::vector<int32_t> vec_pointers_;
+
+ public:
+  PinchDetector() {}
+  virtual ~PinchDetector() {}
+  virtual GESTURE_STATE Detect(const AInputEvent* event);
+  bool GetPointers(Vec2& v1, Vec2& v2);
+};
+
+/******************************************************************
+ * Drag gesture detector
+ * Returns drag gesture state when a drag-tap gesture is detected
+ *
+ */
+class DragDetector : public GestureDetector {
+ private:
+  int32_t FindIndex(const AInputEvent* event, int32_t id);
+  const AInputEvent* event_;
+  std::vector<int32_t> vec_pointers_;
+
+ public:
+  DragDetector() {}
+  virtual ~DragDetector() {}
+  virtual GESTURE_STATE Detect(const AInputEvent* event);
+  bool GetPointer(Vec2& v);
+};
+
+}  // namespace ndkHelper
+#endif /* GESTUREDETECTOR_H_ */

Teapot/app/src/main/jni/ndk_helper/gl3stub.c

@@ -0,0 +1,512 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 <EGL/egl.h>
+#include "gl3stub.h"
+
+GLboolean gl3stubInit()
+{
+#define FIND_PROC(s) s = (void*)eglGetProcAddress(#s);
+    FIND_PROC( glReadBuffer );
+    FIND_PROC( glDrawRangeElements );
+    FIND_PROC( glTexImage3D );
+    FIND_PROC( glTexSubImage3D );
+    FIND_PROC( glCopyTexSubImage3D );
+    FIND_PROC( glCompressedTexImage3D );
+    FIND_PROC( glCompressedTexSubImage3D );
+    FIND_PROC( glGenQueries );
+    FIND_PROC( glDeleteQueries );
+    FIND_PROC( glIsQuery );
+    FIND_PROC( glBeginQuery );
+    FIND_PROC( glEndQuery );
+    FIND_PROC( glGetQueryiv );
+    FIND_PROC( glGetQueryObjectuiv );
+    FIND_PROC( glUnmapBuffer );
+    FIND_PROC( glGetBufferPointerv );
+    FIND_PROC( glDrawBuffers );
+    FIND_PROC( glUniformMatrix2x3fv );
+    FIND_PROC( glUniformMatrix3x2fv );
+    FIND_PROC( glUniformMatrix2x4fv );
+    FIND_PROC( glUniformMatrix4x2fv );
+    FIND_PROC( glUniformMatrix3x4fv );
+    FIND_PROC( glUniformMatrix4x3fv );
+    FIND_PROC( glBlitFramebuffer );
+    FIND_PROC( glRenderbufferStorageMultisample );
+    FIND_PROC( glFramebufferTextureLayer );
+    FIND_PROC( glMapBufferRange );
+    FIND_PROC( glFlushMappedBufferRange );
+    FIND_PROC( glBindVertexArray );
+    FIND_PROC( glDeleteVertexArrays );
+    FIND_PROC( glGenVertexArrays );
+    FIND_PROC( glIsVertexArray );
+    FIND_PROC( glGetIntegeri_v );
+    FIND_PROC( glBeginTransformFeedback );
+    FIND_PROC( glEndTransformFeedback );
+    FIND_PROC( glBindBufferRange );
+    FIND_PROC( glBindBufferBase );
+    FIND_PROC( glTransformFeedbackVaryings );
+    FIND_PROC( glGetTransformFeedbackVarying );
+    FIND_PROC( glVertexAttribIPointer );
+    FIND_PROC( glGetVertexAttribIiv );
+    FIND_PROC( glGetVertexAttribIuiv );
+    FIND_PROC( glVertexAttribI4i );
+    FIND_PROC( glVertexAttribI4ui );
+    FIND_PROC( glVertexAttribI4iv );
+    FIND_PROC( glVertexAttribI4uiv );
+    FIND_PROC( glGetUniformuiv );
+    FIND_PROC( glGetFragDataLocation );
+    FIND_PROC( glUniform1ui );
+    FIND_PROC( glUniform2ui );
+    FIND_PROC( glUniform3ui );
+    FIND_PROC( glUniform4ui );
+    FIND_PROC( glUniform1uiv );
+    FIND_PROC( glUniform2uiv );
+    FIND_PROC( glUniform3uiv );
+    FIND_PROC( glUniform4uiv );
+    FIND_PROC( glClearBufferiv );
+    FIND_PROC( glClearBufferuiv );
+    FIND_PROC( glClearBufferfv );
+    FIND_PROC( glClearBufferfi );
+    FIND_PROC( glGetStringi );
+    FIND_PROC( glCopyBufferSubData );
+    FIND_PROC( glGetUniformIndices );
+    FIND_PROC( glGetActiveUniformsiv );
+    FIND_PROC( glGetUniformBlockIndex );
+    FIND_PROC( glGetActiveUniformBlockiv );
+    FIND_PROC( glGetActiveUniformBlockName );
+    FIND_PROC( glUniformBlockBinding );
+    FIND_PROC( glDrawArraysInstanced );
+    FIND_PROC( glDrawElementsInstanced );
+    FIND_PROC( glFenceSync );
+    FIND_PROC( glIsSync );
+    FIND_PROC( glDeleteSync );
+    FIND_PROC( glClientWaitSync );
+    FIND_PROC( glWaitSync );
+    FIND_PROC( glGetInteger64v );
+    FIND_PROC( glGetSynciv );
+    FIND_PROC( glGetInteger64i_v );
+    FIND_PROC( glGetBufferParameteri64v );
+    FIND_PROC( glGenSamplers );
+    FIND_PROC( glDeleteSamplers );
+    FIND_PROC( glIsSampler );
+    FIND_PROC( glBindSampler );
+    FIND_PROC( glSamplerParameteri );
+    FIND_PROC( glSamplerParameteriv );
+    FIND_PROC( glSamplerParameterf );
+    FIND_PROC( glSamplerParameterfv );
+    FIND_PROC( glGetSamplerParameteriv );
+    FIND_PROC( glGetSamplerParameterfv );
+    FIND_PROC( glVertexAttribDivisor );
+    FIND_PROC( glBindTransformFeedback );
+    FIND_PROC( glDeleteTransformFeedbacks );
+    FIND_PROC( glGenTransformFeedbacks );
+    FIND_PROC( glIsTransformFeedback );
+    FIND_PROC( glPauseTransformFeedback );
+    FIND_PROC( glResumeTransformFeedback );
+    FIND_PROC( glGetProgramBinary );
+    FIND_PROC( glProgramBinary );
+    FIND_PROC( glProgramParameteri );
+    FIND_PROC( glInvalidateFramebuffer );
+    FIND_PROC( glInvalidateSubFramebuffer );
+    FIND_PROC( glTexStorage2D );
+    FIND_PROC( glTexStorage3D );
+    FIND_PROC( glGetInternalformativ );
+#undef FIND_PROC
+
+    if( !glReadBuffer || !glDrawRangeElements || !glTexImage3D || !glTexSubImage3D
+            || !glCopyTexSubImage3D || !glCompressedTexImage3D
+            || !glCompressedTexSubImage3D || !glGenQueries || !glDeleteQueries
+            || !glIsQuery || !glBeginQuery || !glEndQuery || !glGetQueryiv
+            || !glGetQueryObjectuiv || !glUnmapBuffer || !glGetBufferPointerv
+            || !glDrawBuffers || !glUniformMatrix2x3fv || !glUniformMatrix3x2fv
+            || !glUniformMatrix2x4fv || !glUniformMatrix4x2fv || !glUniformMatrix3x4fv
+            || !glUniformMatrix4x3fv || !glBlitFramebuffer
+            || !glRenderbufferStorageMultisample || !glFramebufferTextureLayer
+            || !glMapBufferRange || !glFlushMappedBufferRange || !glBindVertexArray
+            || !glDeleteVertexArrays || !glGenVertexArrays || !glIsVertexArray
+            || !glGetIntegeri_v || !glBeginTransformFeedback || !glEndTransformFeedback
+            || !glBindBufferRange || !glBindBufferBase || !glTransformFeedbackVaryings
+            || !glGetTransformFeedbackVarying || !glVertexAttribIPointer
+            || !glGetVertexAttribIiv || !glGetVertexAttribIuiv || !glVertexAttribI4i
+            || !glVertexAttribI4ui || !glVertexAttribI4iv || !glVertexAttribI4uiv
+            || !glGetUniformuiv || !glGetFragDataLocation || !glUniform1ui
+            || !glUniform2ui || !glUniform3ui || !glUniform4ui || !glUniform1uiv
+            || !glUniform2uiv || !glUniform3uiv || !glUniform4uiv || !glClearBufferiv
+            || !glClearBufferuiv || !glClearBufferfv || !glClearBufferfi || !glGetStringi
+            || !glCopyBufferSubData || !glGetUniformIndices || !glGetActiveUniformsiv
+            || !glGetUniformBlockIndex || !glGetActiveUniformBlockiv
+            || !glGetActiveUniformBlockName || !glUniformBlockBinding
+            || !glDrawArraysInstanced || !glDrawElementsInstanced || !glFenceSync
+            || !glIsSync || !glDeleteSync || !glClientWaitSync || !glWaitSync
+            || !glGetInteger64v || !glGetSynciv || !glGetInteger64i_v
+            || !glGetBufferParameteri64v || !glGenSamplers || !glDeleteSamplers
+            || !glIsSampler || !glBindSampler || !glSamplerParameteri
+            || !glSamplerParameteriv || !glSamplerParameterf || !glSamplerParameterfv
+            || !glGetSamplerParameteriv || !glGetSamplerParameterfv
+            || !glVertexAttribDivisor || !glBindTransformFeedback
+            || !glDeleteTransformFeedbacks || !glGenTransformFeedbacks
+            || !glIsTransformFeedback || !glPauseTransformFeedback
+            || !glResumeTransformFeedback || !glGetProgramBinary || !glProgramBinary
+            || !glProgramParameteri || !glInvalidateFramebuffer
+            || !glInvalidateSubFramebuffer || !glTexStorage2D || !glTexStorage3D
+            || !glGetInternalformativ )
+    {
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+/* Function pointer definitions */GL_APICALL void (* GL_APIENTRY glReadBuffer)( GLenum mode );
+GL_APICALL void (* GL_APIENTRY glDrawRangeElements)( GLenum mode,
+        GLuint start,
+        GLuint end,
+        GLsizei count,
+        GLenum type,
+        const GLvoid* indices );
+GL_APICALL void (* GL_APIENTRY glTexImage3D)( GLenum target,
+        GLint level,
+        GLint internalformat,
+        GLsizei width,
+        GLsizei height,
+        GLsizei depth,
+        GLint border,
+        GLenum format,
+        GLenum type,
+        const GLvoid* pixels );
+GL_APICALL void (* GL_APIENTRY glTexSubImage3D)( GLenum target,
+        GLint level,
+        GLint xoffset,
+        GLint yoffset,
+        GLint zoffset,
+        GLsizei width,
+        GLsizei height,
+        GLsizei depth,
+        GLenum format,
+        GLenum type,
+        const GLvoid* pixels );
+GL_APICALL void (* GL_APIENTRY glCopyTexSubImage3D)( GLenum target,
+        GLint level,
+        GLint xoffset,
+        GLint yoffset,
+        GLint zoffset,
+        GLint x,
+        GLint y,
+        GLsizei width,
+        GLsizei height );
+GL_APICALL void (* GL_APIENTRY glCompressedTexImage3D)( GLenum target,
+        GLint level,
+        GLenum internalformat,
+        GLsizei width,
+        GLsizei height,
+        GLsizei depth,
+        GLint border,
+        GLsizei imageSize,
+        const GLvoid* data );
+GL_APICALL void (* GL_APIENTRY glCompressedTexSubImage3D)( GLenum target,
+        GLint level,
+        GLint xoffset,
+        GLint yoffset,
+        GLint zoffset,
+        GLsizei width,
+        GLsizei height,
+        GLsizei depth,
+        GLenum format,
+        GLsizei imageSize,
+        const GLvoid* data );
+GL_APICALL void (* GL_APIENTRY glGenQueries)( GLsizei n, GLuint* ids );
+GL_APICALL void (* GL_APIENTRY glDeleteQueries)( GLsizei n, const GLuint* ids );
+GL_APICALL GLboolean (* GL_APIENTRY glIsQuery)( GLuint id );
+GL_APICALL void (* GL_APIENTRY glBeginQuery)( GLenum target, GLuint id );
+GL_APICALL void (* GL_APIENTRY glEndQuery)( GLenum target );
+GL_APICALL void (* GL_APIENTRY glGetQueryiv)( GLenum target, GLenum pname, GLint* params );
+GL_APICALL void (* GL_APIENTRY glGetQueryObjectuiv)( GLuint id,
+        GLenum pname,
+        GLuint* params );
+GL_APICALL GLboolean (* GL_APIENTRY glUnmapBuffer)( GLenum target );
+GL_APICALL void (* GL_APIENTRY glGetBufferPointerv)( GLenum target,
+        GLenum pname,
+        GLvoid** params );
+GL_APICALL void (* GL_APIENTRY glDrawBuffers)( GLsizei n, const GLenum* bufs );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix2x3fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix3x2fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix2x4fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix4x2fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix3x4fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glUniformMatrix4x3fv)( GLint location,
+        GLsizei count,
+        GLboolean transpose,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glBlitFramebuffer)( GLint srcX0,
+        GLint srcY0,
+        GLint srcX1,
+        GLint srcY1,
+        GLint dstX0,
+        GLint dstY0,
+        GLint dstX1,
+        GLint dstY1,
+        GLbitfield mask,
+        GLenum filter );
+GL_APICALL void (* GL_APIENTRY glRenderbufferStorageMultisample)( GLenum target,
+        GLsizei samples,
+        GLenum internalformat,
+        GLsizei width,
+        GLsizei height );
+GL_APICALL void (* GL_APIENTRY glFramebufferTextureLayer)( GLenum target,
+        GLenum attachment,
+        GLuint texture,
+        GLint level,
+        GLint layer );
+GL_APICALL GLvoid* (* GL_APIENTRY glMapBufferRange)( GLenum target,
+        GLintptr offset,
+        GLsizeiptr length,
+        GLbitfield access );
+GL_APICALL void (* GL_APIENTRY glFlushMappedBufferRange)( GLenum target,
+        GLintptr offset,
+        GLsizeiptr length );
+GL_APICALL void (* GL_APIENTRY glBindVertexArray)( GLuint array );
+GL_APICALL void (* GL_APIENTRY glDeleteVertexArrays)( GLsizei n, const GLuint* arrays );
+GL_APICALL void (* GL_APIENTRY glGenVertexArrays)( GLsizei n, GLuint* arrays );
+GL_APICALL GLboolean (* GL_APIENTRY glIsVertexArray)( GLuint array );
+GL_APICALL void (* GL_APIENTRY glGetIntegeri_v)( GLenum target,
+        GLuint index,
+        GLint* data );
+GL_APICALL void (* GL_APIENTRY glBeginTransformFeedback)( GLenum primitiveMode );
+GL_APICALL void (* GL_APIENTRY glEndTransformFeedback)( void );
+GL_APICALL void (* GL_APIENTRY glBindBufferRange)( GLenum target,
+        GLuint index,
+        GLuint buffer,
+        GLintptr offset,
+        GLsizeiptr size );
+GL_APICALL void (* GL_APIENTRY glBindBufferBase)( GLenum target,
+        GLuint index,
+        GLuint buffer );
+GL_APICALL void (* GL_APIENTRY glTransformFeedbackVaryings)( GLuint program,
+        GLsizei count,
+        const GLchar* const * varyings,
+        GLenum bufferMode );
+GL_APICALL void (* GL_APIENTRY glGetTransformFeedbackVarying)( GLuint program,
+        GLuint index,
+        GLsizei bufSize,
+        GLsizei* length,
+        GLsizei* size,
+        GLenum* type,
+        GLchar* name );
+GL_APICALL void (* GL_APIENTRY glVertexAttribIPointer)( GLuint index,
+        GLint size,
+        GLenum type,
+        GLsizei stride,
+        const GLvoid* pointer );
+GL_APICALL void (* GL_APIENTRY glGetVertexAttribIiv)( GLuint index,
+        GLenum pname,
+        GLint* params );
+GL_APICALL void (* GL_APIENTRY glGetVertexAttribIuiv)( GLuint index,
+        GLenum pname,
+        GLuint* params );
+GL_APICALL void (* GL_APIENTRY glVertexAttribI4i)( GLuint index,
+        GLint x,
+        GLint y,
+        GLint z,
+        GLint w );
+GL_APICALL void (* GL_APIENTRY glVertexAttribI4ui)( GLuint index,
+        GLuint x,
+        GLuint y,
+        GLuint z,
+        GLuint w );
+GL_APICALL void (* GL_APIENTRY glVertexAttribI4iv)( GLuint index, const GLint* v );
+GL_APICALL void (* GL_APIENTRY glVertexAttribI4uiv)( GLuint index, const GLuint* v );
+GL_APICALL void (* GL_APIENTRY glGetUniformuiv)( GLuint program,
+        GLint location,
+        GLuint* params );
+GL_APICALL GLint (* GL_APIENTRY glGetFragDataLocation)( GLuint program,
+        const GLchar *name );
+GL_APICALL void (* GL_APIENTRY glUniform1ui)( GLint location, GLuint v0 );
+GL_APICALL void (* GL_APIENTRY glUniform2ui)( GLint location, GLuint v0, GLuint v1 );
+GL_APICALL void (* GL_APIENTRY glUniform3ui)( GLint location,
+        GLuint v0,
+        GLuint v1,
+        GLuint v2 );
+GL_APICALL void (* GL_APIENTRY glUniform4ui)( GLint location,
+        GLuint v0,
+        GLuint v1,
+        GLuint v2,
+        GLuint v3 );
+GL_APICALL void (* GL_APIENTRY glUniform1uiv)( GLint location,
+        GLsizei count,
+        const GLuint* value );
+GL_APICALL void (* GL_APIENTRY glUniform2uiv)( GLint location,
+        GLsizei count,
+        const GLuint* value );
+GL_APICALL void (* GL_APIENTRY glUniform3uiv)( GLint location,
+        GLsizei count,
+        const GLuint* value );
+GL_APICALL void (* GL_APIENTRY glUniform4uiv)( GLint location,
+        GLsizei count,
+        const GLuint* value );
+GL_APICALL void (* GL_APIENTRY glClearBufferiv)( GLenum buffer,
+        GLint drawbuffer,
+        const GLint* value );
+GL_APICALL void (* GL_APIENTRY glClearBufferuiv)( GLenum buffer,
+        GLint drawbuffer,
+        const GLuint* value );
+GL_APICALL void (* GL_APIENTRY glClearBufferfv)( GLenum buffer,
+        GLint drawbuffer,
+        const GLfloat* value );
+GL_APICALL void (* GL_APIENTRY glClearBufferfi)( GLenum buffer,
+        GLint drawbuffer,
+        GLfloat depth,
+        GLint stencil );
+GL_APICALL const GLubyte* (* GL_APIENTRY glGetStringi)( GLenum name, GLuint index );
+GL_APICALL void (* GL_APIENTRY glCopyBufferSubData)( GLenum readTarget,
+        GLenum writeTarget,
+        GLintptr readOffset,
+        GLintptr writeOffset,
+        GLsizeiptr size );
+GL_APICALL void (* GL_APIENTRY glGetUniformIndices)( GLuint program,
+        GLsizei uniformCount,
+        const GLchar* const * uniformNames,
+        GLuint* uniformIndices );
+GL_APICALL void (* GL_APIENTRY glGetActiveUniformsiv)( GLuint program,
+        GLsizei uniformCount,
+        const GLuint* uniformIndices,
+        GLenum pname,
+        GLint* params );
+GL_APICALL GLuint (* GL_APIENTRY glGetUniformBlockIndex)( GLuint program,
+        const GLchar* uniformBlockName );
+GL_APICALL void (* GL_APIENTRY glGetActiveUniformBlockiv)( GLuint program,
+        GLuint uniformBlockIndex,
+        GLenum pname,
+        GLint* params );
+GL_APICALL void (* GL_APIENTRY glGetActiveUniformBlockName)( GLuint program,
+        GLuint uniformBlockIndex,
+        GLsizei bufSize,
+        GLsizei* length,
+        GLchar* uniformBlockName );
+GL_APICALL void (* GL_APIENTRY glUniformBlockBinding)( GLuint program,
+        GLuint uniformBlockIndex,
+        GLuint uniformBlockBinding );
+GL_APICALL void (* GL_APIENTRY glDrawArraysInstanced)( GLenum mode,
+        GLint first,
+        GLsizei count,
+        GLsizei instanceCount );
+GL_APICALL void (* GL_APIENTRY glDrawElementsInstanced)( GLenum mode,
+        GLsizei count,
+        GLenum type,
+        const GLvoid* indices,
+        GLsizei instanceCount );
+GL_APICALL GLsync (* GL_APIENTRY glFenceSync)( GLenum condition, GLbitfield flags );
+GL_APICALL GLboolean (* GL_APIENTRY glIsSync)( GLsync sync );
+GL_APICALL void (* GL_APIENTRY glDeleteSync)( GLsync sync );
+GL_APICALL GLenum (* GL_APIENTRY glClientWaitSync)( GLsync sync,
+        GLbitfield flags,
+        GLuint64 timeout );
+GL_APICALL void (* GL_APIENTRY glWaitSync)( GLsync sync,
+        GLbitfield flags,
+        GLuint64 timeout );
+GL_APICALL void (* GL_APIENTRY glGetInteger64v)( GLenum pname, GLint64* params );
+GL_APICALL void (* GL_APIENTRY glGetSynciv)( GLsync sync,
+        GLenum pname,
+        GLsizei bufSize,
+        GLsizei* length,
+        GLint* values );
+GL_APICALL void (* GL_APIENTRY glGetInteger64i_v)( GLenum target,
+        GLuint index,
+        GLint64* data );
+GL_APICALL void (* GL_APIENTRY glGetBufferParameteri64v)( GLenum target,
+        GLenum pname,
+        GLint64* params );
+GL_APICALL void (* GL_APIENTRY glGenSamplers)( GLsizei count, GLuint* samplers );
+GL_APICALL void (* GL_APIENTRY glDeleteSamplers)( GLsizei count, const GLuint* samplers );
+GL_APICALL GLboolean (* GL_APIENTRY glIsSampler)( GLuint sampler );
+GL_APICALL void (* GL_APIENTRY glBindSampler)( GLuint unit, GLuint sampler );
+GL_APICALL void (* GL_APIENTRY glSamplerParameteri)( GLuint sampler,
+        GLenum pname,
+        GLint param );
+GL_APICALL void (* GL_APIENTRY glSamplerParameteriv)( GLuint sampler,
+        GLenum pname,
+        const GLint* param );
+GL_APICALL void (* GL_APIENTRY glSamplerParameterf)( GLuint sampler,
+        GLenum pname,
+        GLfloat param );
+GL_APICALL void (* GL_APIENTRY glSamplerParameterfv)( GLuint sampler,
+        GLenum pname,
+        const GLfloat* param );
+GL_APICALL void (* GL_APIENTRY glGetSamplerParameteriv)( GLuint sampler,
+        GLenum pname,
+        GLint* params );
+GL_APICALL void (* GL_APIENTRY glGetSamplerParameterfv)( GLuint sampler,
+        GLenum pname,
+        GLfloat* params );
+GL_APICALL void (* GL_APIENTRY glVertexAttribDivisor)( GLuint index, GLuint divisor );
+GL_APICALL void (* GL_APIENTRY glBindTransformFeedback)( GLenum target, GLuint id );
+GL_APICALL void (* GL_APIENTRY glDeleteTransformFeedbacks)( GLsizei n, const GLuint* ids );
+GL_APICALL void (* GL_APIENTRY glGenTransformFeedbacks)( GLsizei n, GLuint* ids );
+GL_APICALL GLboolean (* GL_APIENTRY glIsTransformFeedback)( GLuint id );
+GL_APICALL void (* GL_APIENTRY glPauseTransformFeedback)( void );
+GL_APICALL void (* GL_APIENTRY glResumeTransformFeedback)( void );
+GL_APICALL void (* GL_APIENTRY glGetProgramBinary)( GLuint program,
+        GLsizei bufSize,
+        GLsizei* length,
+        GLenum* binaryFormat,
+        GLvoid* binary );
+GL_APICALL void (* GL_APIENTRY glProgramBinary)( GLuint program,
+        GLenum binaryFormat,
+        const GLvoid* binary,
+        GLsizei length );
+GL_APICALL void (* GL_APIENTRY glProgramParameteri)( GLuint program,
+        GLenum pname,
+        GLint value );
+GL_APICALL void (* GL_APIENTRY glInvalidateFramebuffer)( GLenum target,
+        GLsizei numAttachments,
+        const GLenum* attachments );
+GL_APICALL void (* GL_APIENTRY glInvalidateSubFramebuffer)( GLenum target,
+        GLsizei numAttachments,
+        const GLenum* attachments,
+        GLint x,
+        GLint y,
+        GLsizei width,
+        GLsizei height );
+GL_APICALL void (* GL_APIENTRY glTexStorage2D)( GLenum target,
+        GLsizei levels,
+        GLenum internalformat,
+        GLsizei width,
+        GLsizei height );
+GL_APICALL void (* GL_APIENTRY glTexStorage3D)( GLenum target,
+        GLsizei levels,
+        GLenum internalformat,
+        GLsizei width,
+        GLsizei height,
+        GLsizei depth );
+GL_APICALL void (* GL_APIENTRY glGetInternalformativ)( GLenum target,
+        GLenum internalformat,
+        GLenum pname,
+        GLsizei bufSize,
+        GLint* params );

Teapot/app/src/main/jni/ndk_helper/gl3stub.h

@@ -0,0 +1,663 @@
+#ifndef __gl3_h_
+#define __gl3_h_
+
+/*
+ * stub gl3.h for dynamic loading, based on:
+ * gl3.h last updated on $Date: 2013-02-12 14:37:24 -0800 (Tue, 12 Feb 2013) $
+ *
+ * Changes:
+ * - Added #include <GLES2/gl2.h>
+ * - Removed duplicate OpenGL ES 2.0 declarations
+ * - Converted OpenGL ES 3.0 function prototypes to function pointer
+ *   declarations
+ * - Added gl3stubInit() declaration
+ */
+
+#include <GLES2/gl2.h>
+#include <android/api-level.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ ** Copyright (c) 2007-2013 The Khronos Group Inc.
+ **
+ ** Permission is hereby granted, free of charge, to any person obtaining a
+ ** copy of this software and/or associated documentation files (the
+ ** "Materials"), to deal in the Materials without restriction, including
+ ** without limitation the rights to use, copy, modify, merge, publish,
+ ** distribute, sublicense, and/or sell copies of the Materials, and to
+ ** permit persons to whom the Materials are 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 Materials.
+ **
+ ** THE MATERIALS ARE 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
+ ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ */
+
+/*
+ * This files is for apps that want to use ES3 if present,
+ * but continue to work on pre-API-18 devices. They can't just link to -lGLESv3
+ *since
+ * that library doesn't exist on pre-API-18 devices.
+ * The function dynamically check if OpenGLES3.0 APIs are present and fill in if
+ *there are.
+ * Also the header defines some extra variables for OpenGLES3.0.
+ *
+ */
+
+/* Call this function before calling any OpenGL ES 3.0 functions. It will
+ * return GL_TRUE if the OpenGL ES 3.0 was successfully initialized, GL_FALSE
+ * otherwise. */
+GLboolean gl3stubInit();
+
+/*-------------------------------------------------------------------------
+ * Data type definitions
+ *-----------------------------------------------------------------------*/
+
+/* OpenGL ES 3.0 */
+
+typedef unsigned short GLhalf;
+#if __ANDROID_API__ <= 19
+typedef khronos_int64_t GLint64;
+typedef khronos_uint64_t GLuint64;
+typedef struct __GLsync* GLsync;
+#endif
+
+/*-------------------------------------------------------------------------
+ * Token definitions
+ *-----------------------------------------------------------------------*/
+
+/* OpenGL ES core versions */
+#define GL_ES_VERSION_3_0 1
+
+/* OpenGL ES 3.0 */
+
+#define GL_READ_BUFFER 0x0C02
+#define GL_UNPACK_ROW_LENGTH 0x0CF2
+#define GL_UNPACK_SKIP_ROWS 0x0CF3
+#define GL_UNPACK_SKIP_PIXELS 0x0CF4
+#define GL_PACK_ROW_LENGTH 0x0D02
+#define GL_PACK_SKIP_ROWS 0x0D03
+#define GL_PACK_SKIP_PIXELS 0x0D04
+#define GL_COLOR 0x1800
+#define GL_DEPTH 0x1801
+#define GL_STENCIL 0x1802
+#define GL_RED 0x1903
+#define GL_RGB8 0x8051
+#define GL_RGBA8 0x8058
+#define GL_RGB10_A2 0x8059
+#define GL_TEXTURE_BINDING_3D 0x806A
+#define GL_UNPACK_SKIP_IMAGES 0x806D
+#define GL_UNPACK_IMAGE_HEIGHT 0x806E
+#define GL_TEXTURE_3D 0x806F
+#define GL_TEXTURE_WRAP_R 0x8072
+#define GL_MAX_3D_TEXTURE_SIZE 0x8073
+#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
+#define GL_MAX_ELEMENTS_VERTICES 0x80E8
+#define GL_MAX_ELEMENTS_INDICES 0x80E9
+#define GL_TEXTURE_MIN_LOD 0x813A
+#define GL_TEXTURE_MAX_LOD 0x813B
+#define GL_TEXTURE_BASE_LEVEL 0x813C
+#define GL_TEXTURE_MAX_LEVEL 0x813D
+#define GL_MIN 0x8007
+#define GL_MAX 0x8008
+#define GL_DEPTH_COMPONENT24 0x81A6
+#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
+#define GL_TEXTURE_COMPARE_MODE 0x884C
+#define GL_TEXTURE_COMPARE_FUNC 0x884D
+#define GL_CURRENT_QUERY 0x8865
+#define GL_QUERY_RESULT 0x8866
+#define GL_QUERY_RESULT_AVAILABLE 0x8867
+#define GL_BUFFER_MAPPED 0x88BC
+#define GL_BUFFER_MAP_POINTER 0x88BD
+#define GL_STREAM_READ 0x88E1
+#define GL_STREAM_COPY 0x88E2
+#define GL_STATIC_READ 0x88E5
+#define GL_STATIC_COPY 0x88E6
+#define GL_DYNAMIC_READ 0x88E9
+#define GL_DYNAMIC_COPY 0x88EA
+#define GL_MAX_DRAW_BUFFERS 0x8824
+#define GL_DRAW_BUFFER0 0x8825
+#define GL_DRAW_BUFFER1 0x8826
+#define GL_DRAW_BUFFER2 0x8827
+#define GL_DRAW_BUFFER3 0x8828
+#define GL_DRAW_BUFFER4 0x8829
+#define GL_DRAW_BUFFER5 0x882A
+#define GL_DRAW_BUFFER6 0x882B
+#define GL_DRAW_BUFFER7 0x882C
+#define GL_DRAW_BUFFER8 0x882D
+#define GL_DRAW_BUFFER9 0x882E
+#define GL_DRAW_BUFFER10 0x882F
+#define GL_DRAW_BUFFER11 0x8830
+#define GL_DRAW_BUFFER12 0x8831
+#define GL_DRAW_BUFFER13 0x8832
+#define GL_DRAW_BUFFER14 0x8833
+#define GL_DRAW_BUFFER15 0x8834
+#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
+#define GL_SAMPLER_3D 0x8B5F
+#define GL_SAMPLER_2D_SHADOW 0x8B62
+#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
+#define GL_PIXEL_PACK_BUFFER 0x88EB
+#define GL_PIXEL_UNPACK_BUFFER 0x88EC
+#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
+#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
+#define GL_FLOAT_MAT2x3 0x8B65
+#define GL_FLOAT_MAT2x4 0x8B66
+#define GL_FLOAT_MAT3x2 0x8B67
+#define GL_FLOAT_MAT3x4 0x8B68
+#define GL_FLOAT_MAT4x2 0x8B69
+#define GL_FLOAT_MAT4x3 0x8B6A
+#define GL_SRGB 0x8C40
+#define GL_SRGB8 0x8C41
+#define GL_SRGB8_ALPHA8 0x8C43
+#define GL_COMPARE_REF_TO_TEXTURE 0x884E
+#define GL_MAJOR_VERSION 0x821B
+#define GL_MINOR_VERSION 0x821C
+#define GL_NUM_EXTENSIONS 0x821D
+#define GL_RGBA32F 0x8814
+#define GL_RGB32F 0x8815
+#define GL_RGBA16F 0x881A
+#define GL_RGB16F 0x881B
+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD
+#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF
+#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904
+#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905
+#define GL_MAX_VARYING_COMPONENTS 0x8B4B
+#define GL_TEXTURE_2D_ARRAY 0x8C1A
+#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D
+#define GL_R11F_G11F_B10F 0x8C3A
+#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B
+#define GL_RGB9_E5 0x8C3D
+#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E
+#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
+#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
+#define GL_RASTERIZER_DISCARD 0x8C89
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
+#define GL_INTERLEAVED_ATTRIBS 0x8C8C
+#define GL_SEPARATE_ATTRIBS 0x8C8D
+#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
+#define GL_RGBA32UI 0x8D70
+#define GL_RGB32UI 0x8D71
+#define GL_RGBA16UI 0x8D76
+#define GL_RGB16UI 0x8D77
+#define GL_RGBA8UI 0x8D7C
+#define GL_RGB8UI 0x8D7D
+#define GL_RGBA32I 0x8D82
+#define GL_RGB32I 0x8D83
+#define GL_RGBA16I 0x8D88
+#define GL_RGB16I 0x8D89
+#define GL_RGBA8I 0x8D8E
+#define GL_RGB8I 0x8D8F
+#define GL_RED_INTEGER 0x8D94
+#define GL_RGB_INTEGER 0x8D98
+#define GL_RGBA_INTEGER 0x8D99
+#define GL_SAMPLER_2D_ARRAY 0x8DC1
+#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4
+#define GL_SAMPLER_CUBE_SHADOW 0x8DC5
+#define GL_UNSIGNED_INT_VEC2 0x8DC6
+#define GL_UNSIGNED_INT_VEC3 0x8DC7
+#define GL_UNSIGNED_INT_VEC4 0x8DC8
+#define GL_INT_SAMPLER_2D 0x8DCA
+#define GL_INT_SAMPLER_3D 0x8DCB
+#define GL_INT_SAMPLER_CUBE 0x8DCC
+#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF
+#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2
+#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3
+#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4
+#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7
+#define GL_BUFFER_ACCESS_FLAGS 0x911F
+#define GL_BUFFER_MAP_LENGTH 0x9120
+#define GL_BUFFER_MAP_OFFSET 0x9121
+#define GL_DEPTH_COMPONENT32F 0x8CAC
+#define GL_DEPTH32F_STENCIL8 0x8CAD
+#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
+#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
+#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
+#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
+#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
+#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
+#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
+#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
+#define GL_FRAMEBUFFER_DEFAULT 0x8218
+#define GL_FRAMEBUFFER_UNDEFINED 0x8219
+#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
+#define GL_DEPTH_STENCIL 0x84F9
+#define GL_UNSIGNED_INT_24_8 0x84FA
+#define GL_DEPTH24_STENCIL8 0x88F0
+#define GL_UNSIGNED_NORMALIZED 0x8C17
+#define GL_DRAW_FRAMEBUFFER_BINDING GL_FRAMEBUFFER_BINDING
+#define GL_READ_FRAMEBUFFER 0x8CA8
+#define GL_DRAW_FRAMEBUFFER 0x8CA9
+#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA
+#define GL_RENDERBUFFER_SAMPLES 0x8CAB
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
+#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
+#define GL_COLOR_ATTACHMENT1 0x8CE1
+#define GL_COLOR_ATTACHMENT2 0x8CE2
+#define GL_COLOR_ATTACHMENT3 0x8CE3
+#define GL_COLOR_ATTACHMENT4 0x8CE4
+#define GL_COLOR_ATTACHMENT5 0x8CE5
+#define GL_COLOR_ATTACHMENT6 0x8CE6
+#define GL_COLOR_ATTACHMENT7 0x8CE7
+#define GL_COLOR_ATTACHMENT8 0x8CE8
+#define GL_COLOR_ATTACHMENT9 0x8CE9
+#define GL_COLOR_ATTACHMENT10 0x8CEA
+#define GL_COLOR_ATTACHMENT11 0x8CEB
+#define GL_COLOR_ATTACHMENT12 0x8CEC
+#define GL_COLOR_ATTACHMENT13 0x8CED
+#define GL_COLOR_ATTACHMENT14 0x8CEE
+#define GL_COLOR_ATTACHMENT15 0x8CEF
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
+#define GL_MAX_SAMPLES 0x8D57
+#define GL_HALF_FLOAT 0x140B
+#define GL_MAP_READ_BIT 0x0001
+#define GL_MAP_WRITE_BIT 0x0002
+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
+#define GL_RG 0x8227
+#define GL_RG_INTEGER 0x8228
+#define GL_R8 0x8229
+#define GL_RG8 0x822B
+#define GL_R16F 0x822D
+#define GL_R32F 0x822E
+#define GL_RG16F 0x822F
+#define GL_RG32F 0x8230
+#define GL_R8I 0x8231
+#define GL_R8UI 0x8232
+#define GL_R16I 0x8233
+#define GL_R16UI 0x8234
+#define GL_R32I 0x8235
+#define GL_R32UI 0x8236
+#define GL_RG8I 0x8237
+#define GL_RG8UI 0x8238
+#define GL_RG16I 0x8239
+#define GL_RG16UI 0x823A
+#define GL_RG32I 0x823B
+#define GL_RG32UI 0x823C
+#define GL_VERTEX_ARRAY_BINDING 0x85B5
+#define GL_R8_SNORM 0x8F94
+#define GL_RG8_SNORM 0x8F95
+#define GL_RGB8_SNORM 0x8F96
+#define GL_RGBA8_SNORM 0x8F97
+#define GL_SIGNED_NORMALIZED 0x8F9C
+#define GL_PRIMITIVE_RESTART_FIXED_INDEX 0x8D69
+#define GL_COPY_READ_BUFFER 0x8F36
+#define GL_COPY_WRITE_BUFFER 0x8F37
+#define GL_COPY_READ_BUFFER_BINDING GL_COPY_READ_BUFFER
+#define GL_COPY_WRITE_BUFFER_BINDING GL_COPY_WRITE_BUFFER
+#define GL_UNIFORM_BUFFER 0x8A11
+#define GL_UNIFORM_BUFFER_BINDING 0x8A28
+#define GL_UNIFORM_BUFFER_START 0x8A29
+#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
+#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
+#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
+#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
+#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
+#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
+#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
+#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
+#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
+#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
+#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
+#define GL_UNIFORM_TYPE 0x8A37
+#define GL_UNIFORM_SIZE 0x8A38
+#define GL_UNIFORM_NAME_LENGTH 0x8A39
+#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
+#define GL_UNIFORM_OFFSET 0x8A3B
+#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
+#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
+#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
+#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
+#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
+#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
+#define GL_INVALID_INDEX 0xFFFFFFFFu
+#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
+#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
+#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
+#define GL_OBJECT_TYPE 0x9112
+#define GL_SYNC_CONDITION 0x9113
+#define GL_SYNC_STATUS 0x9114
+#define GL_SYNC_FLAGS 0x9115
+#define GL_SYNC_FENCE 0x9116
+#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
+#define GL_UNSIGNALED 0x9118
+#define GL_SIGNALED 0x9119
+#define GL_ALREADY_SIGNALED 0x911A
+#define GL_TIMEOUT_EXPIRED 0x911B
+#define GL_CONDITION_SATISFIED 0x911C
+#define GL_WAIT_FAILED 0x911D
+#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
+#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFFull
+#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE
+#define GL_ANY_SAMPLES_PASSED 0x8C2F
+#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE 0x8D6A
+#define GL_SAMPLER_BINDING 0x8919
+#define GL_RGB10_A2UI 0x906F
+#define GL_TEXTURE_SWIZZLE_R 0x8E42
+#define GL_TEXTURE_SWIZZLE_G 0x8E43
+#define GL_TEXTURE_SWIZZLE_B 0x8E44
+#define GL_TEXTURE_SWIZZLE_A 0x8E45
+#define GL_GREEN 0x1904
+#define GL_BLUE 0x1905
+#define GL_INT_2_10_10_10_REV 0x8D9F
+#define GL_TRANSFORM_FEEDBACK 0x8E22
+#define GL_TRANSFORM_FEEDBACK_PAUSED 0x8E23
+#define GL_TRANSFORM_FEEDBACK_ACTIVE 0x8E24
+#define GL_TRANSFORM_FEEDBACK_BINDING 0x8E25
+#define GL_PROGRAM_BINARY_RETRIEVABLE_HINT 0x8257
+#define GL_PROGRAM_BINARY_LENGTH 0x8741
+#define GL_NUM_PROGRAM_BINARY_FORMATS 0x87FE
+#define GL_PROGRAM_BINARY_FORMATS 0x87FF
+#define GL_COMPRESSED_R11_EAC 0x9270
+#define GL_COMPRESSED_SIGNED_R11_EAC 0x9271
+#define GL_COMPRESSED_RG11_EAC 0x9272
+#define GL_COMPRESSED_SIGNED_RG11_EAC 0x9273
+#define GL_COMPRESSED_RGB8_ETC2 0x9274
+#define GL_COMPRESSED_SRGB8_ETC2 0x9275
+#define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276
+#define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277
+#define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278
+#define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279
+#define GL_TEXTURE_IMMUTABLE_FORMAT 0x912F
+#define GL_MAX_ELEMENT_INDEX 0x8D6B
+#define GL_NUM_SAMPLE_COUNTS 0x9380
+#define GL_TEXTURE_IMMUTABLE_LEVELS 0x82DF
+
+/*-------------------------------------------------------------------------
+ * Entrypoint definitions
+ *-----------------------------------------------------------------------*/
+
+/* OpenGL ES 3.0 */
+
+extern GL_APICALL void (*GL_APIENTRY glReadBuffer)(GLenum mode);
+extern GL_APICALL void (*GL_APIENTRY glDrawRangeElements)(
+    GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
+    const GLvoid* indices);
+extern GL_APICALL void (*GL_APIENTRY glTexImage3D)(
+    GLenum target, GLint level, GLint internalformat, GLsizei width,
+    GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type,
+    const GLvoid* pixels);
+extern GL_APICALL void (*GL_APIENTRY glTexSubImage3D)(
+    GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
+    GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type,
+    const GLvoid* pixels);
+extern GL_APICALL void (*GL_APIENTRY glCopyTexSubImage3D)(
+    GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
+    GLint x, GLint y, GLsizei width, GLsizei height);
+extern GL_APICALL void (*GL_APIENTRY glCompressedTexImage3D)(
+    GLenum target, GLint level, GLenum internalformat, GLsizei width,
+    GLsizei height, GLsizei depth, GLint border, GLsizei imageSize,
+    const GLvoid* data);
+extern GL_APICALL void (*GL_APIENTRY glCompressedTexSubImage3D)(
+    GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
+    GLsizei width, GLsizei height, GLsizei depth, GLenum format,
+    GLsizei imageSize, const GLvoid* data);
+extern GL_APICALL void (*GL_APIENTRY glGenQueries)(GLsizei n, GLuint* ids);
+extern GL_APICALL void (*GL_APIENTRY glDeleteQueries)(GLsizei n,
+                                                      const GLuint* ids);
+extern GL_APICALL GLboolean (*GL_APIENTRY glIsQuery)(GLuint id);
+extern GL_APICALL void (*GL_APIENTRY glBeginQuery)(GLenum target, GLuint id);
+extern GL_APICALL void (*GL_APIENTRY glEndQuery)(GLenum target);
+extern GL_APICALL void (*GL_APIENTRY glGetQueryiv)(GLenum target, GLenum pname,
+                                                   GLint* params);
+extern GL_APICALL void (*GL_APIENTRY glGetQueryObjectuiv)(GLuint id,
+                                                          GLenum pname,
+                                                          GLuint* params);
+extern GL_APICALL GLboolean (*GL_APIENTRY glUnmapBuffer)(GLenum target);
+extern GL_APICALL void (*GL_APIENTRY glGetBufferPointerv)(GLenum target,
+                                                          GLenum pname,
+                                                          GLvoid** params);
+extern GL_APICALL void (*GL_APIENTRY glDrawBuffers)(GLsizei n,
+                                                    const GLenum* bufs);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix2x3fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix3x2fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix2x4fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix4x2fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix3x4fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glUniformMatrix4x3fv)(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY glBlitFramebuffer)(
+    GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0,
+    GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+extern GL_APICALL void (*GL_APIENTRY glRenderbufferStorageMultisample)(
+    GLenum target, GLsizei samples, GLenum internalformat, GLsizei width,
+    GLsizei height);
+extern GL_APICALL void (*GL_APIENTRY glFramebufferTextureLayer)(
+    GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+extern GL_APICALL GLvoid* (*GL_APIENTRY glMapBufferRange)(GLenum target,
+                                                          GLintptr offset,
+                                                          GLsizeiptr length,
+                                                          GLbitfield access);
+extern GL_APICALL void (*GL_APIENTRY glFlushMappedBufferRange)(
+    GLenum target, GLintptr offset, GLsizeiptr length);
+extern GL_APICALL void (*GL_APIENTRY glBindVertexArray)(GLuint array);
+extern GL_APICALL void (*GL_APIENTRY
+                            glDeleteVertexArrays)(GLsizei n,
+                                                  const GLuint* arrays);
+extern GL_APICALL void (*GL_APIENTRY glGenVertexArrays)(GLsizei n,
+                                                        GLuint* arrays);
+extern GL_APICALL GLboolean (*GL_APIENTRY glIsVertexArray)(GLuint array);
+extern GL_APICALL void (*GL_APIENTRY glGetIntegeri_v)(GLenum target,
+                                                      GLuint index,
+                                                      GLint* data);
+extern GL_APICALL void (*GL_APIENTRY
+                            glBeginTransformFeedback)(GLenum primitiveMode);
+extern GL_APICALL void (*GL_APIENTRY glEndTransformFeedback)(void);
+extern GL_APICALL void (*GL_APIENTRY
+                            glBindBufferRange)(GLenum target, GLuint index,
+                                               GLuint buffer, GLintptr offset,
+                                               GLsizeiptr size);
+extern GL_APICALL void (*GL_APIENTRY glBindBufferBase)(GLenum target,
+                                                       GLuint index,
+                                                       GLuint buffer);
+extern GL_APICALL void (*GL_APIENTRY glTransformFeedbackVaryings)(
+    GLuint program, GLsizei count, const GLchar* const* varyings,
+    GLenum bufferMode);
+extern GL_APICALL void (*GL_APIENTRY glGetTransformFeedbackVarying)(
+    GLuint program, GLuint index, GLsizei bufSize, GLsizei* length,
+    GLsizei* size, GLenum* type, GLchar* name);
+extern GL_APICALL void (*GL_APIENTRY
+                            glVertexAttribIPointer)(GLuint index, GLint size,
+                                                    GLenum type, GLsizei stride,
+                                                    const GLvoid* pointer);
+extern GL_APICALL void (*GL_APIENTRY glGetVertexAttribIiv)(GLuint index,
+                                                           GLenum pname,
+                                                           GLint* params);
+extern GL_APICALL void (*GL_APIENTRY glGetVertexAttribIuiv)(GLuint index,
+                                                            GLenum pname,
+                                                            GLuint* params);
+extern GL_APICALL void (*GL_APIENTRY glVertexAttribI4i)(GLuint index, GLint x,
+                                                        GLint y, GLint z,
+                                                        GLint w);
+extern GL_APICALL void (*GL_APIENTRY glVertexAttribI4ui)(GLuint index, GLuint x,
+                                                         GLuint y, GLuint z,
+                                                         GLuint w);
+extern GL_APICALL void (*GL_APIENTRY glVertexAttribI4iv)(GLuint index,
+                                                         const GLint* v);
+extern GL_APICALL void (*GL_APIENTRY glVertexAttribI4uiv)(GLuint index,
+                                                          const GLuint* v);
+extern GL_APICALL void (*GL_APIENTRY glGetUniformuiv)(GLuint program,
+                                                      GLint location,
+                                                      GLuint* params);
+extern GL_APICALL GLint (*GL_APIENTRY
+                             glGetFragDataLocation)(GLuint program,
+                                                    const GLchar* name);
+extern GL_APICALL void (*GL_APIENTRY glUniform1ui)(GLint location, GLuint v0);
+extern GL_APICALL void (*GL_APIENTRY glUniform2ui)(GLint location, GLuint v0,
+                                                   GLuint v1);
+extern GL_APICALL void (*GL_APIENTRY glUniform3ui)(GLint location, GLuint v0,
+                                                   GLuint v1, GLuint v2);
+extern GL_APICALL void (*GL_APIENTRY glUniform4ui)(GLint location, GLuint v0,
+                                                   GLuint v1, GLuint v2,
+                                                   GLuint v3);
+extern GL_APICALL void (*GL_APIENTRY glUniform1uiv)(GLint location,
+                                                    GLsizei count,
+                                                    const GLuint* value);
+extern GL_APICALL void (*GL_APIENTRY glUniform2uiv)(GLint location,
+                                                    GLsizei count,
+                                                    const GLuint* value);
+extern GL_APICALL void (*GL_APIENTRY glUniform3uiv)(GLint location,
+                                                    GLsizei count,
+                                                    const GLuint* value);
+extern GL_APICALL void (*GL_APIENTRY glUniform4uiv)(GLint location,
+                                                    GLsizei count,
+                                                    const GLuint* value);
+extern GL_APICALL void (*GL_APIENTRY glClearBufferiv)(GLenum buffer,
+                                                      GLint drawbuffer,
+                                                      const GLint* value);
+extern GL_APICALL void (*GL_APIENTRY glClearBufferuiv)(GLenum buffer,
+                                                       GLint drawbuffer,
+                                                       const GLuint* value);
+extern GL_APICALL void (*GL_APIENTRY glClearBufferfv)(GLenum buffer,
+                                                      GLint drawbuffer,
+                                                      const GLfloat* value);
+extern GL_APICALL void (*GL_APIENTRY
+                            glClearBufferfi)(GLenum buffer, GLint drawbuffer,
+                                             GLfloat depth, GLint stencil);
+extern GL_APICALL const GLubyte* (*GL_APIENTRY glGetStringi)(GLenum name,
+                                                             GLuint index);
+extern GL_APICALL void (*GL_APIENTRY glCopyBufferSubData)(GLenum readTarget,
+                                                          GLenum writeTarget,
+                                                          GLintptr readOffset,
+                                                          GLintptr writeOffset,
+                                                          GLsizeiptr size);
+extern GL_APICALL void (*GL_APIENTRY glGetUniformIndices)(
+    GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames,
+    GLuint* uniformIndices);
+extern GL_APICALL void (*GL_APIENTRY glGetActiveUniformsiv)(
+    GLuint program, GLsizei uniformCount, const GLuint* uniformIndices,
+    GLenum pname, GLint* params);
+extern GL_APICALL GLuint (*GL_APIENTRY glGetUniformBlockIndex)(
+    GLuint program, const GLchar* uniformBlockName);
+extern GL_APICALL void (*GL_APIENTRY glGetActiveUniformBlockiv)(
+    GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params);
+extern GL_APICALL void (*GL_APIENTRY glGetActiveUniformBlockName)(
+    GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length,
+    GLchar* uniformBlockName);
+extern GL_APICALL void (*GL_APIENTRY glUniformBlockBinding)(
+    GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+extern GL_APICALL void (*GL_APIENTRY glDrawArraysInstanced)(
+    GLenum mode, GLint first, GLsizei count, GLsizei instanceCount);
+extern GL_APICALL void (*GL_APIENTRY glDrawElementsInstanced)(
+    GLenum mode, GLsizei count, GLenum type, const GLvoid* indices,
+    GLsizei instanceCount);
+extern GL_APICALL GLsync (*GL_APIENTRY glFenceSync)(GLenum condition,
+                                                    GLbitfield flags);
+extern GL_APICALL GLboolean (*GL_APIENTRY glIsSync)(GLsync sync);
+extern GL_APICALL void (*GL_APIENTRY glDeleteSync)(GLsync sync);
+extern GL_APICALL GLenum (*GL_APIENTRY glClientWaitSync)(GLsync sync,
+                                                         GLbitfield flags,
+                                                         GLuint64 timeout);
+extern GL_APICALL void (*GL_APIENTRY glWaitSync)(GLsync sync, GLbitfield flags,
+                                                 GLuint64 timeout);
+extern GL_APICALL void (*GL_APIENTRY glGetInteger64v)(GLenum pname,
+                                                      GLint64* params);
+extern GL_APICALL void (*GL_APIENTRY glGetSynciv)(GLsync sync, GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  GLint* values);
+extern GL_APICALL void (*GL_APIENTRY glGetInteger64i_v)(GLenum target,
+                                                        GLuint index,
+                                                        GLint64* data);
+extern GL_APICALL void (*GL_APIENTRY glGetBufferParameteri64v)(GLenum target,
+                                                               GLenum pname,
+                                                               GLint64* params);
+extern GL_APICALL void (*GL_APIENTRY glGenSamplers)(GLsizei count,
+                                                    GLuint* samplers);
+extern GL_APICALL void (*GL_APIENTRY glDeleteSamplers)(GLsizei count,
+                                                       const GLuint* samplers);
+extern GL_APICALL GLboolean (*GL_APIENTRY glIsSampler)(GLuint sampler);
+extern GL_APICALL void (*GL_APIENTRY glBindSampler)(GLuint unit,
+                                                    GLuint sampler);
+extern GL_APICALL void (*GL_APIENTRY glSamplerParameteri)(GLuint sampler,
+                                                          GLenum pname,
+                                                          GLint param);
+extern GL_APICALL void (*GL_APIENTRY glSamplerParameteriv)(GLuint sampler,
+                                                           GLenum pname,
+                                                           const GLint* param);
+extern GL_APICALL void (*GL_APIENTRY glSamplerParameterf)(GLuint sampler,
+                                                          GLenum pname,
+                                                          GLfloat param);
+extern GL_APICALL void (*GL_APIENTRY
+                            glSamplerParameterfv)(GLuint sampler, GLenum pname,
+                                                  const GLfloat* param);
+extern GL_APICALL void (*GL_APIENTRY glGetSamplerParameteriv)(GLuint sampler,
+                                                              GLenum pname,
+                                                              GLint* params);
+extern GL_APICALL void (*GL_APIENTRY glGetSamplerParameterfv)(GLuint sampler,
+                                                              GLenum pname,
+                                                              GLfloat* params);
+extern GL_APICALL void (*GL_APIENTRY glVertexAttribDivisor)(GLuint index,
+                                                            GLuint divisor);
+extern GL_APICALL void (*GL_APIENTRY glBindTransformFeedback)(GLenum target,
+                                                              GLuint id);
+extern GL_APICALL void (*GL_APIENTRY
+                            glDeleteTransformFeedbacks)(GLsizei n,
+                                                        const GLuint* ids);
+extern GL_APICALL void (*GL_APIENTRY glGenTransformFeedbacks)(GLsizei n,
+                                                              GLuint* ids);
+extern GL_APICALL GLboolean (*GL_APIENTRY glIsTransformFeedback)(GLuint id);
+extern GL_APICALL void (*GL_APIENTRY glPauseTransformFeedback)(void);
+extern GL_APICALL void (*GL_APIENTRY glResumeTransformFeedback)(void);
+extern GL_APICALL void (*GL_APIENTRY glGetProgramBinary)(GLuint program,
+                                                         GLsizei bufSize,
+                                                         GLsizei* length,
+                                                         GLenum* binaryFormat,
+                                                         GLvoid* binary);
+extern GL_APICALL void (*GL_APIENTRY glProgramBinary)(GLuint program,
+                                                      GLenum binaryFormat,
+                                                      const GLvoid* binary,
+                                                      GLsizei length);
+extern GL_APICALL void (*GL_APIENTRY glProgramParameteri)(GLuint program,
+                                                          GLenum pname,
+                                                          GLint value);
+extern GL_APICALL void (*GL_APIENTRY glInvalidateFramebuffer)(
+    GLenum target, GLsizei numAttachments, const GLenum* attachments);
+extern GL_APICALL void (*GL_APIENTRY glInvalidateSubFramebuffer)(
+    GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x,
+    GLint y, GLsizei width, GLsizei height);
+extern GL_APICALL void (*GL_APIENTRY
+                            glTexStorage2D)(GLenum target, GLsizei levels,
+                                            GLenum internalformat,
+                                            GLsizei width, GLsizei height);
+extern GL_APICALL void (*GL_APIENTRY glTexStorage3D)(
+    GLenum target, GLsizei levels, GLenum internalformat, GLsizei width,
+    GLsizei height, GLsizei depth);
+extern GL_APICALL void (*GL_APIENTRY glGetInternalformativ)(
+    GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize,
+    GLint* params);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Teapot/app/src/main/jni/ndk_helper/interpolator.cpp

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 "interpolator.h"
+#include <math.h>
+#include "interpolator.h"
+
+namespace ndk_helper {
+
+//-------------------------------------------------
+// Ctor
+//-------------------------------------------------
+Interpolator::Interpolator() { list_params_.clear(); }
+
+//-------------------------------------------------
+// Dtor
+//-------------------------------------------------
+Interpolator::~Interpolator() { list_params_.clear(); }
+
+void Interpolator::Clear() { list_params_.clear(); }
+
+Interpolator& Interpolator::Set(const float start, const float dest,
+                                const INTERPOLATOR_TYPE type,
+                                const double duration) {
+  // init the parameters for the interpolation process
+  start_time_ = PerfMonitor::GetCurrentTime();
+  dest_time_ = start_time_ + duration;
+  type_ = type;
+
+  start_value_ = start;
+  dest_value_ = dest;
+  return *this;
+}
+
+Interpolator& Interpolator::Add(const float dest, const INTERPOLATOR_TYPE type,
+                                const double duration) {
+  InterpolatorParams param;
+  param.dest_value_ = dest;
+  param.type_ = type;
+  param.duration_ = duration;
+  list_params_.push_back(param);
+  return *this;
+}
+
+bool Interpolator::Update(const double current_time, float& p) {
+  bool bContinue;
+  if (current_time >= dest_time_) {
+    p = dest_value_;
+    if (list_params_.size()) {
+      InterpolatorParams& item = list_params_.front();
+      Set(dest_value_, item.dest_value_, item.type_, item.duration_);
+      list_params_.pop_front();
+
+      bContinue = true;
+    } else {
+      bContinue = false;
+    }
+  } else {
+    float t = (float)(current_time - start_time_);
+    float d = (float)(dest_time_ - start_time_);
+    float b = start_value_;
+    float c = dest_value_ - start_value_;
+    p = GetFormula(type_, t, b, d, c);
+
+    bContinue = true;
+  }
+  return bContinue;
+}
+
+float Interpolator::GetFormula(const INTERPOLATOR_TYPE type, const float t,
+                               const float b, const float d, const float c) {
+  float t1;
+  switch (type) {
+    case INTERPOLATOR_TYPE_LINEAR:
+      // simple linear interpolation - no easing
+      return (c * t / d + b);
+
+    case INTERPOLATOR_TYPE_EASEINQUAD:
+      // quadratic (t^2) easing in - accelerating from zero velocity
+      t1 = t / d;
+      return (c * t1 * t1 + b);
+
+    case INTERPOLATOR_TYPE_EASEOUTQUAD:
+      // quadratic (t^2) easing out - decelerating to zero velocity
+      t1 = t / d;
+      return (-c * t1 * (t1 - 2) + b);
+
+    case INTERPOLATOR_TYPE_EASEINOUTQUAD:
+      // quadratic easing in/out - acceleration until halfway, then deceleration
+      t1 = t / d / 2;
+      if (t1 < 1)
+        return (c / 2 * t1 * t1 + b);
+      else {
+        t1 = t1 - 1;
+        return (-c / 2 * (t1 * (t1 - 2) - 1) + b);
+      }
+    case INTERPOLATOR_TYPE_EASEINCUBIC:
+      // cubic easing in - accelerating from zero velocity
+      t1 = t / d;
+      return (c * t1 * t1 * t1 + b);
+
+    case INTERPOLATOR_TYPE_EASEOUTCUBIC:
+      // cubic easing in - accelerating from zero velocity
+      t1 = t / d - 1;
+      return (c * (t1 * t1 * t1 + 1) + b);
+
+    case INTERPOLATOR_TYPE_EASEINOUTCUBIC:
+      // cubic easing in - accelerating from zero velocity
+      t1 = t / d / 2;
+
+      if (t1 < 1)
+        return (c / 2 * t1 * t1 * t1 + b);
+      else {
+        t1 -= 2;
+        return (c / 2 * (t1 * t1 * t1 + 2) + b);
+      }
+    case INTERPOLATOR_TYPE_EASEINQUART:
+      // quartic easing in - accelerating from zero velocity
+      t1 = t / d;
+      return (c * t1 * t1 * t1 * t1 + b);
+
+    case INTERPOLATOR_TYPE_EASEINEXPO:
+      // exponential (2^t) easing in - accelerating from zero velocity
+      if (t == 0)
+        return b;
+      else
+        return (c * powf(2, (10 * (t / d - 1))) + b);
+
+    case INTERPOLATOR_TYPE_EASEOUTEXPO:
+      // exponential (2^t) easing out - decelerating to zero velocity
+      if (t == d)
+        return (b + c);
+      else
+        return (c * (-powf(2, -10 * t / d) + 1) + b);
+    default:
+      return 0;
+  }
+}
+
+}  // namespace ndkHelper

Teapot/app/src/main/jni/ndk_helper/interpolator.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 INTERPOLATOR_H_
+#define INTERPOLATOR_H_
+
+#include <jni.h>
+#include <errno.h>
+#include <time.h>
+#include "JNIHelper.h"
+#include "perfMonitor.h"
+#include <list>
+
+namespace ndk_helper {
+
+enum INTERPOLATOR_TYPE {
+  INTERPOLATOR_TYPE_LINEAR,
+  INTERPOLATOR_TYPE_EASEINQUAD,
+  INTERPOLATOR_TYPE_EASEOUTQUAD,
+  INTERPOLATOR_TYPE_EASEINOUTQUAD,
+  INTERPOLATOR_TYPE_EASEINCUBIC,
+  INTERPOLATOR_TYPE_EASEOUTCUBIC,
+  INTERPOLATOR_TYPE_EASEINOUTCUBIC,
+  INTERPOLATOR_TYPE_EASEINQUART,
+  INTERPOLATOR_TYPE_EASEINEXPO,
+  INTERPOLATOR_TYPE_EASEOUTEXPO,
+};
+
+struct InterpolatorParams {
+  float dest_value_;
+  INTERPOLATOR_TYPE type_;
+  double duration_;
+};
+
+/******************************************************************
+ * Interpolates values with several interpolation methods
+ */
+class Interpolator {
+ private:
+  double start_time_;
+  double dest_time_;
+  INTERPOLATOR_TYPE type_;
+
+  float start_value_;
+  float dest_value_;
+  std::list<InterpolatorParams> list_params_;
+
+  float GetFormula(const INTERPOLATOR_TYPE type, const float t, const float b,
+                   const float d, const float c);
+
+ public:
+  Interpolator();
+  ~Interpolator();
+
+  Interpolator& Set(const float start, const float dest,
+                    const INTERPOLATOR_TYPE type, double duration);
+
+  Interpolator& Add(const float dest, const INTERPOLATOR_TYPE type,
+                    const double duration);
+
+  bool Update(const double currentTime, float& p);
+
+  void Clear();
+};
+
+}  // namespace ndkHelper
+#endif /* INTERPOLATOR_H_ */

Teapot/app/src/main/jni/ndk_helper/perfMonitor.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 "perfMonitor.h"
+
+namespace ndk_helper {
+
+PerfMonitor::PerfMonitor() {
+  for (int32_t i = 0; i < NUM_SAMPLES; ++i) ticklist_[i] = 0;
+}
+
+PerfMonitor::~PerfMonitor() {}
+
+double PerfMonitor::UpdateTick(double currentTick) {
+  ticksum_ -= ticklist_[tickindex_];
+  ticksum_ += currentTick;
+  ticklist_[tickindex_] = currentTick;
+  tickindex_ = (tickindex_ + 1) % NUM_SAMPLES;
+
+  return ((double)ticksum_ / NUM_SAMPLES);
+}
+
+bool PerfMonitor::Update(float &fFPS) {
+  struct timeval Time;
+  gettimeofday(&Time, NULL);
+
+  double time = Time.tv_sec + Time.tv_usec * 1.0 / 1000000.0;
+  double tick = time - last_tick_;
+  double d = UpdateTick(tick);
+  last_tick_ = time;
+
+  if (Time.tv_sec - tv_last_sec_ >= 1) {
+    current_FPS_ = 1.f / d;
+    tv_last_sec_ = Time.tv_sec;
+    fFPS = current_FPS_;
+    return true;
+  } else {
+    fFPS = current_FPS_;
+    return false;
+  }
+}
+
+}  // namespace ndkHelper

Teapot/app/src/main/jni/ndk_helper/perfMonitor.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 PERFMONITOR_H_
+#define PERFMONITOR_H_
+
+#include <jni.h>
+#include <errno.h>
+#include <time.h>
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+const int32_t NUM_SAMPLES = 100;
+
+/******************************************************************
+ * Helper class for a performance monitoring and get current tick time
+ */
+class PerfMonitor {
+ private:
+  float current_FPS_;
+  time_t tv_last_sec_ {0};
+
+  double last_tick_{static_cast<double>(0.0)};
+  int32_t tickindex_ {0};
+  double ticksum_ {0.0};
+  double ticklist_[NUM_SAMPLES];
+
+  double UpdateTick(double current_tick);
+
+ public:
+  PerfMonitor();
+  virtual ~PerfMonitor();
+
+  bool Update(float &fFPS);
+
+  static double GetCurrentTime() {
+    struct timeval time;
+    gettimeofday(&time, NULL);
+    double ret = time.tv_sec + time.tv_usec * 1.0 / 1000000.0;
+    return ret;
+  }
+};
+
+}  // namespace ndkHelper
+#endif /* PERFMONITOR_H_ */

Teapot/app/src/main/jni/ndk_helper/shader.cpp

@@ -0,0 +1,167 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 <EGL/egl.h>
+#include <GLES2/gl2.h>
+
+#include "shader.h"
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+#define DEBUG (1)
+
+bool shader::CompileShader(
+    GLuint *shader, const GLenum type, const char *str_file_name,
+    const std::map<std::string, std::string> &map_parameters) {
+  std::vector<uint8_t> data;
+  if (!JNIHelper::GetInstance()->ReadFile(str_file_name, &data)) {
+    LOGI("Can not open a file:%s", str_file_name);
+    return false;
+  }
+
+  const char REPLACEMENT_TAG = '*';
+  // Fill-in parameters
+  std::string str(data.begin(), data.end());
+  std::string str_replacement_map(data.size(), ' ');
+
+  std::map<std::string, std::string>::const_iterator it =
+      map_parameters.begin();
+  std::map<std::string, std::string>::const_iterator itEnd =
+      map_parameters.end();
+  while (it != itEnd) {
+    size_t pos = 0;
+    while ((pos = str.find(it->first, pos)) != std::string::npos) {
+      // Check if the sub string is already touched
+
+      size_t replaced_pos = str_replacement_map.find(REPLACEMENT_TAG, pos);
+      if (replaced_pos == std::string::npos || replaced_pos > pos) {
+
+        str.replace(pos, it->first.length(), it->second);
+        str_replacement_map.replace(pos, it->first.length(), it->first.length(),
+                                    REPLACEMENT_TAG);
+        pos += it->second.length();
+      } else {
+        // The replacement target has been touched by other tag, skipping them
+        pos += it->second.length();
+      }
+    }
+    it++;
+  }
+
+  LOGI("Patched Shdader:\n%s", str.c_str());
+
+  std::vector<uint8_t> v(str.begin(), str.end());
+  str.clear();
+  return shader::CompileShader(shader, type, v);
+}
+
+bool shader::CompileShader(GLuint *shader, const GLenum type,
+                           const GLchar *source, const int32_t iSize) {
+  if (source == NULL || iSize <= 0) return false;
+
+  *shader = glCreateShader(type);
+  glShaderSource(*shader, 1, &source, &iSize);  // Not specifying 3rd parameter
+                                                // (size) could be troublesome..
+
+  glCompileShader(*shader);
+
+#if defined(DEBUG)
+  GLint logLength;
+  glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength);
+  if (logLength > 0) {
+    GLchar *log = (GLchar *)malloc(logLength);
+    glGetShaderInfoLog(*shader, logLength, &logLength, log);
+    LOGI("Shader compile log:\n%s", log);
+    free(log);
+  }
+#endif
+
+  GLint status;
+  glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);
+  if (status == 0) {
+    glDeleteShader(*shader);
+    return false;
+  }
+
+  return true;
+}
+
+bool shader::CompileShader(GLuint *shader, const GLenum type,
+                           std::vector<uint8_t> &data) {
+  if (!data.size()) return false;
+
+  const GLchar *source = (GLchar *)&data[0];
+  int32_t iSize = data.size();
+  return shader::CompileShader(shader, type, source, iSize);
+}
+
+bool shader::CompileShader(GLuint *shader, const GLenum type,
+                           const char *strFileName) {
+  std::vector<uint8_t> data;
+  bool b = JNIHelper::GetInstance()->ReadFile(strFileName, &data);
+  if (!b) {
+    LOGI("Can not open a file:%s", strFileName);
+    return false;
+  }
+
+  return shader::CompileShader(shader, type, data);
+}
+
+bool shader::LinkProgram(const GLuint prog) {
+  GLint status;
+
+  glLinkProgram(prog);
+
+#if defined(DEBUG)
+  GLint logLength;
+  glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLength);
+  if (logLength > 0) {
+    GLchar *log = (GLchar *)malloc(logLength);
+    glGetProgramInfoLog(prog, logLength, &logLength, log);
+    LOGI("Program link log:\n%s", log);
+    free(log);
+  }
+#endif
+
+  glGetProgramiv(prog, GL_LINK_STATUS, &status);
+  if (status == 0) {
+    LOGI("Program link failed\n");
+    return false;
+  }
+
+  return true;
+}
+
+bool shader::ValidateProgram(const GLuint prog) {
+  GLint logLength, status;
+
+  glValidateProgram(prog);
+  glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLength);
+  if (logLength > 0) {
+    GLchar *log = (GLchar *)malloc(logLength);
+    glGetProgramInfoLog(prog, logLength, &logLength, log);
+    LOGI("Program validate log:\n%s", log);
+    free(log);
+  }
+
+  glGetProgramiv(prog, GL_VALIDATE_STATUS, &status);
+  if (status == 0) return false;
+
+  return true;
+}
+
+}  // namespace ndkHelper

Teapot/app/src/main/jni/ndk_helper/shader.h

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 SHADER_H_
+#define SHADER_H_
+
+#include <jni.h>
+
+#include <vector>
+#include <map>
+#include <string>
+
+#include <EGL/egl.h>
+#include <GLES/gl.h>
+
+#include <android/log.h>
+
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+namespace shader {
+
+/******************************************************************
+ * Shader compiler helper
+ * namespace: ndkHelper::shader
+ *
+ */
+
+/******************************************************************
+ * CompileShader() with vector
+ *
+ * arguments:
+ *  out: shader, shader variable
+ *  in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
+ *  in: data, source vector
+ * return: true if a shader compilation succeeded, false if it failed
+ *
+ */
+bool CompileShader(GLuint *shader, const GLenum type,
+                   std::vector<uint8_t> &data);
+
+/******************************************************************
+ * CompileShader() with buffer
+ *
+ * arguments:
+ *  out: shader, shader variable
+ *  in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
+ *  in: source, source buffer
+ *  in: iSize, buffer size
+ * return: true if a shader compilation succeeded, false if it failed
+ *
+ */
+bool CompileShader(GLuint *shader, const GLenum type, const GLchar *source,
+                   const int32_t iSize);
+
+/******************************************************************
+ * CompileShader() with filename
+ *
+ * arguments:
+ *  out: shader, shader variable
+ *  in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
+ *  in: strFilename, filename
+ * return: true if a shader compilation succeeded, false if it failed
+ *
+ */
+bool CompileShader(GLuint *shader, const GLenum type, const char *strFileName);
+
+/******************************************************************
+ * CompileShader() with std::map helps patching on a shader on the fly.
+ *
+ * arguments:
+ *  out: shader, shader variable
+ *  in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
+ *  in: mapParameters
+ *      For a example,
+ *      map : %KEY% -> %VALUE% replaces all %KEY% entries in the given shader
+ *code to %VALUE"
+ * return: true if a shader compilation succeeded, false if it failed
+ *
+ */
+bool CompileShader(GLuint *shader, const GLenum type, const char *str_file_name,
+                   const std::map<std::string, std::string> &map_parameters);
+
+/******************************************************************
+ * LinkProgram()
+ *
+ * arguments:
+ *  in: program, program
+ * return: true if a shader linkage succeeded, false if it failed
+ *
+ */
+bool LinkProgram(const GLuint prog);
+
+/******************************************************************
+ * validateProgram()
+ *
+ * arguments:
+ *  in: program, program
+ * return: true if a shader validation succeeded, false if it failed
+ *
+ */
+bool ValidateProgram(const GLuint prog);
+}  // namespace shader
+
+}  // namespace ndkHelper
+#endif /* SHADER_H_ */

Teapot/app/src/main/jni/ndk_helper/tapCamera.cpp

@@ -0,0 +1,271 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//----------------------------------------------------------
+//  tapCamera.cpp
+//  Camera control with tap
+//
+//----------------------------------------------------------
+#include <fstream>
+#include "tapCamera.h"
+
+namespace ndk_helper {
+
+const float TRANSFORM_FACTOR = 15.f;
+const float TRANSFORM_FACTORZ = 10.f;
+
+const float MOMENTUM_FACTOR_DECREASE = 0.85f;
+const float MOMENTUM_FACTOR_DECREASE_SHIFT = 0.9f;
+const float MOMENTUM_FACTOR = 0.8f;
+const float MOMENTUM_FACTOR_THRESHOLD = 0.001f;
+
+//----------------------------------------------------------
+//  Ctor
+//----------------------------------------------------------
+TapCamera::TapCamera() {
+  // Init offset
+  InitParameters();
+
+  vec_flip_ = Vec2(1.f, -1.f);
+  flip_z_ = -1.f;
+  vec_pinch_transform_factor_ = Vec3(1.f, 1.f, 1.f);
+
+  vec_ball_center_ = Vec2(0, 0);
+  vec_ball_now_ = Vec2(0, 0);
+  vec_ball_down_ = Vec2(0, 0);
+
+  vec_pinch_start_ = Vec2(0, 0);
+  vec_pinch_start_center_ = Vec2(0, 0);
+
+  vec_flip_ = Vec2(0, 0);
+}
+
+void TapCamera::InitParameters() {
+  // Init parameters
+  vec_offset_ = Vec3();
+  vec_offset_now_ = Vec3();
+
+  quat_ball_rot_ = Quaternion();
+  quat_ball_now_ = Quaternion();
+  quat_ball_now_.ToMatrix(mat_rotation_);
+  camera_rotation_ = 0.f;
+
+  vec_drag_delta_ = Vec2();
+  vec_offset_delta_ = Vec3();
+
+  momentum_ = false;
+}
+
+//----------------------------------------------------------
+//  Dtor
+//----------------------------------------------------------
+TapCamera::~TapCamera() {}
+
+void TapCamera::Update() {
+  if (momentum_) {
+    float momenttum_steps = momemtum_steps_;
+
+    // Momentum rotation
+    Vec2 v = vec_drag_delta_;
+    BeginDrag(Vec2());  // NOTE:This call reset _VDragDelta
+    Drag(v * vec_flip_);
+
+    // Momentum shift
+    vec_offset_ += vec_offset_delta_;
+
+    BallUpdate();
+    EndDrag();
+
+    // Decrease deltas
+    vec_drag_delta_ = v * MOMENTUM_FACTOR_DECREASE;
+    vec_offset_delta_ = vec_offset_delta_ * MOMENTUM_FACTOR_DECREASE_SHIFT;
+
+    // Count steps
+    momemtum_steps_ = momenttum_steps * MOMENTUM_FACTOR_DECREASE;
+    if (momemtum_steps_ < MOMENTUM_FACTOR_THRESHOLD) {
+      momentum_ = false;
+    }
+  } else {
+    vec_drag_delta_ *= MOMENTUM_FACTOR;
+    vec_offset_delta_ = vec_offset_delta_ * MOMENTUM_FACTOR;
+    BallUpdate();
+  }
+
+  Vec3 vec = vec_offset_ + vec_offset_now_;
+  Vec3 vec_tmp(TRANSFORM_FACTOR, -TRANSFORM_FACTOR, TRANSFORM_FACTORZ);
+
+  vec *= vec_tmp * vec_pinch_transform_factor_;
+
+  mat_transform_ = Mat4::Translation(vec);
+}
+
+Mat4& TapCamera::GetRotationMatrix() { return mat_rotation_; }
+
+Mat4& TapCamera::GetTransformMatrix() { return mat_transform_; }
+
+void TapCamera::Reset(const bool bAnimate) {
+  InitParameters();
+  Update();
+}
+
+//----------------------------------------------------------
+// Drag control
+//----------------------------------------------------------
+void TapCamera::BeginDrag(const Vec2& v) {
+  if (dragging_) EndDrag();
+
+  if (pinching_) EndPinch();
+
+  Vec2 vec = v * vec_flip_;
+  vec_ball_now_ = vec;
+  vec_ball_down_ = vec_ball_now_;
+
+  dragging_ = true;
+  momentum_ = false;
+  vec_last_input_ = vec;
+  vec_drag_delta_ = Vec2();
+}
+
+void TapCamera::EndDrag() {
+  quat_ball_down_ = quat_ball_now_;
+  quat_ball_rot_ = Quaternion();
+
+  dragging_ = false;
+  momentum_ = true;
+  momemtum_steps_ = 1.0f;
+}
+
+void TapCamera::Drag(const Vec2& v) {
+  if (!dragging_) return;
+
+  Vec2 vec = v * vec_flip_;
+  vec_ball_now_ = vec;
+
+  vec_drag_delta_ = vec_drag_delta_ * MOMENTUM_FACTOR + (vec - vec_last_input_);
+  vec_last_input_ = vec;
+}
+
+//----------------------------------------------------------
+// Pinch controll
+//----------------------------------------------------------
+void TapCamera::BeginPinch(const Vec2& v1, const Vec2& v2) {
+  if (dragging_) EndDrag();
+
+  if (pinching_) EndPinch();
+
+  BeginDrag(Vec2());
+
+  vec_pinch_start_center_ = (v1 + v2) / 2.f;
+
+  Vec2 vec = v1 - v2;
+  float x_diff;
+  float y_diff;
+  vec.Value(x_diff, y_diff);
+
+  pinch_start_distance_SQ_ = x_diff * x_diff + y_diff * y_diff;
+  camera_rotation_start_ = atan2f(y_diff, x_diff);
+  camera_rotation_now_ = 0;
+
+  pinching_ = true;
+  momentum_ = false;
+
+  // Init momentum factors
+  vec_offset_delta_ = Vec3();
+}
+
+void TapCamera::EndPinch() {
+  pinching_ = false;
+  momentum_ = true;
+  momemtum_steps_ = 1.f;
+  vec_offset_ += vec_offset_now_;
+  camera_rotation_ += camera_rotation_now_;
+  vec_offset_now_ = Vec3();
+
+  camera_rotation_now_ = 0;
+
+  EndDrag();
+}
+
+void TapCamera::Pinch(const Vec2& v1, const Vec2& v2) {
+  if (!pinching_) return;
+
+  // Update momentum factor
+  vec_offset_last_ = vec_offset_now_;
+
+  float x_diff, y_diff;
+  Vec2 vec = v1 - v2;
+  vec.Value(x_diff, y_diff);
+
+  float fDistanceSQ = x_diff * x_diff + y_diff * y_diff;
+
+  float f = pinch_start_distance_SQ_ / fDistanceSQ;
+  if (f < 1.f)
+    f = -1.f / f + 1.0f;
+  else
+    f = f - 1.f;
+  if (isnan(f)) f = 0.f;
+
+  vec = (v1 + v2) / 2.f - vec_pinch_start_center_;
+  vec_offset_now_ = Vec3(vec, flip_z_ * f);
+
+  // Update momentum factor
+  vec_offset_delta_ = vec_offset_delta_ * MOMENTUM_FACTOR +
+                      (vec_offset_now_ - vec_offset_last_);
+
+  //
+  // Update ration quaternion
+  float fRotation = atan2f(y_diff, x_diff);
+  camera_rotation_now_ = fRotation - camera_rotation_start_;
+
+  // Trackball rotation
+  quat_ball_rot_ = Quaternion(0.f, 0.f, sinf(-camera_rotation_now_ * 0.5f),
+                              cosf(-camera_rotation_now_ * 0.5f));
+}
+
+//----------------------------------------------------------
+// Trackball controll
+//----------------------------------------------------------
+void TapCamera::BallUpdate() {
+  if (dragging_) {
+    Vec3 vec_from = PointOnSphere(vec_ball_down_);
+    Vec3 vec_to = PointOnSphere(vec_ball_now_);
+
+    Vec3 vec = vec_from.Cross(vec_to);
+    float w = vec_from.Dot(vec_to);
+
+    Quaternion qDrag = Quaternion(vec, w);
+    qDrag = qDrag * quat_ball_down_;
+    quat_ball_now_ = quat_ball_rot_ * qDrag;
+  }
+  quat_ball_now_.ToMatrix(mat_rotation_);
+}
+
+Vec3 TapCamera::PointOnSphere(Vec2& point) {
+  Vec3 ball_mouse;
+  float mag;
+  Vec2 vec = (point - vec_ball_center_) / ball_radius_;
+  mag = vec.Dot(vec);
+  if (mag > 1.f) {
+    float scale = 1.f / sqrtf(mag);
+    vec *= scale;
+    ball_mouse = Vec3(vec, 0.f);
+  } else {
+    ball_mouse = Vec3(vec, sqrtf(1.f - mag));
+  }
+  return ball_mouse;
+}
+
+}  // namespace ndkHelper

Teapot/app/src/main/jni/ndk_helper/tapCamera.h

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+#include <vector>
+#include <string>
+#include <GLES2/gl2.h>
+
+#include "JNIHelper.h"
+#include "vecmath.h"
+#include "interpolator.h"
+
+namespace ndk_helper {
+
+/******************************************************************
+ * Camera control helper class with a tap gesture
+ * This class is mainly used for 3D space camera control in samples.
+ *
+ */
+class TapCamera {
+ private:
+  // Trackball
+  Vec2 vec_ball_center_;
+  float ball_radius_ {0.75f};
+  Quaternion quat_ball_now_;
+  Quaternion quat_ball_down_;
+  Vec2 vec_ball_now_;
+  Vec2 vec_ball_down_;
+  Quaternion quat_ball_rot_;
+
+  bool dragging_ {false};
+  bool pinching_ {false};
+
+  // Pinch related info
+  Vec2 vec_pinch_start_;
+  Vec2 vec_pinch_start_center_;
+  float pinch_start_distance_SQ_ {0.0f};
+
+  // Camera shift
+  Vec3 vec_offset_;
+  Vec3 vec_offset_now_;
+
+  // Camera Rotation
+  float camera_rotation_ {0.0f};
+  float camera_rotation_start_ {0.0f};
+  float camera_rotation_now_ {0.0f};
+
+  // Momentum support
+  bool momentum_ {false};
+  Vec2 vec_drag_delta_;
+  Vec2 vec_last_input_;
+  Vec3 vec_offset_last_;
+  Vec3 vec_offset_delta_;
+  float momemtum_steps_;
+
+  Vec2 vec_flip_;
+  float flip_z_ {0.0f};
+
+  Mat4 mat_rotation_;
+  Mat4 mat_transform_;
+
+  Vec3 vec_pinch_transform_factor_;
+
+  Vec3 PointOnSphere(Vec2& point);
+  void BallUpdate();
+  void InitParameters();
+
+ public:
+  TapCamera();
+  virtual ~TapCamera();
+  void BeginDrag(const Vec2& vec);
+  void EndDrag();
+  void Drag(const Vec2& vec);
+  void Update();
+
+  Mat4& GetRotationMatrix();
+  Mat4& GetTransformMatrix();
+
+  void BeginPinch(const Vec2& v1, const Vec2& v2);
+  void EndPinch();
+  void Pinch(const Vec2& v1, const Vec2& v2);
+
+  void SetFlip(const float x, const float y, const float z) {
+    vec_flip_ = Vec2(x, y);
+    flip_z_ = z;
+  }
+
+  void SetPinchTransformFactor(const float x, const float y, const float z) {
+    vec_pinch_transform_factor_ = Vec3(x, y, z);
+  }
+
+  void Reset(const bool bAnimate);
+};
+
+}  // namespace ndkHelper

Teapot/app/src/main/jni/ndk_helper/vecmath.cpp

@@ -0,0 +1,362 @@
+/*
+ * Copy_right 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * y_ou may_ not use this file ex_cept 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 ex_press or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//--------------------------------------------------------------------------------
+// vecmath.cpp
+//--------------------------------------------------------------------------------
+#include "vecmath.h"
+
+namespace ndk_helper {
+
+//--------------------------------------------------------------------------------
+// vec3
+//--------------------------------------------------------------------------------
+Vec3::Vec3(const Vec4& vec) {
+  x_ = vec.x_;
+  y_ = vec.y_;
+  z_ = vec.z_;
+}
+
+//--------------------------------------------------------------------------------
+// vec4
+//--------------------------------------------------------------------------------
+Vec4 Vec4::operator*(const Mat4& rhs) const {
+  Vec4 out;
+  out.x_ = x_ * rhs.f_[0] + y_ * rhs.f_[1] + z_ * rhs.f_[2] + w_ * rhs.f_[3];
+  out.y_ = x_ * rhs.f_[4] + y_ * rhs.f_[5] + z_ * rhs.f_[6] + w_ * rhs.f_[7];
+  out.z_ = x_ * rhs.f_[8] + y_ * rhs.f_[9] + z_ * rhs.f_[10] + w_ * rhs.f_[11];
+  out.w_ =
+      x_ * rhs.f_[12] + y_ * rhs.f_[13] + z_ * rhs.f_[14] + w_ * rhs.f_[15];
+  return out;
+}
+
+//--------------------------------------------------------------------------------
+// mat4
+//--------------------------------------------------------------------------------
+Mat4::Mat4() {
+  for (int32_t i = 0; i < 16; ++i) f_[i] = 0.f;
+}
+
+Mat4::Mat4(const float* mIn) {
+  for (int32_t i = 0; i < 16; ++i) f_[i] = mIn[i];
+}
+
+Mat4 Mat4::operator*(const Mat4& rhs) const {
+  Mat4 ret;
+  ret.f_[0] = f_[0] * rhs.f_[0] + f_[4] * rhs.f_[1] + f_[8] * rhs.f_[2] +
+              f_[12] * rhs.f_[3];
+  ret.f_[1] = f_[1] * rhs.f_[0] + f_[5] * rhs.f_[1] + f_[9] * rhs.f_[2] +
+              f_[13] * rhs.f_[3];
+  ret.f_[2] = f_[2] * rhs.f_[0] + f_[6] * rhs.f_[1] + f_[10] * rhs.f_[2] +
+              f_[14] * rhs.f_[3];
+  ret.f_[3] = f_[3] * rhs.f_[0] + f_[7] * rhs.f_[1] + f_[11] * rhs.f_[2] +
+              f_[15] * rhs.f_[3];
+
+  ret.f_[4] = f_[0] * rhs.f_[4] + f_[4] * rhs.f_[5] + f_[8] * rhs.f_[6] +
+              f_[12] * rhs.f_[7];
+  ret.f_[5] = f_[1] * rhs.f_[4] + f_[5] * rhs.f_[5] + f_[9] * rhs.f_[6] +
+              f_[13] * rhs.f_[7];
+  ret.f_[6] = f_[2] * rhs.f_[4] + f_[6] * rhs.f_[5] + f_[10] * rhs.f_[6] +
+              f_[14] * rhs.f_[7];
+  ret.f_[7] = f_[3] * rhs.f_[4] + f_[7] * rhs.f_[5] + f_[11] * rhs.f_[6] +
+              f_[15] * rhs.f_[7];
+
+  ret.f_[8] = f_[0] * rhs.f_[8] + f_[4] * rhs.f_[9] + f_[8] * rhs.f_[10] +
+              f_[12] * rhs.f_[11];
+  ret.f_[9] = f_[1] * rhs.f_[8] + f_[5] * rhs.f_[9] + f_[9] * rhs.f_[10] +
+              f_[13] * rhs.f_[11];
+  ret.f_[10] = f_[2] * rhs.f_[8] + f_[6] * rhs.f_[9] + f_[10] * rhs.f_[10] +
+               f_[14] * rhs.f_[11];
+  ret.f_[11] = f_[3] * rhs.f_[8] + f_[7] * rhs.f_[9] + f_[11] * rhs.f_[10] +
+               f_[15] * rhs.f_[11];
+
+  ret.f_[12] = f_[0] * rhs.f_[12] + f_[4] * rhs.f_[13] + f_[8] * rhs.f_[14] +
+               f_[12] * rhs.f_[15];
+  ret.f_[13] = f_[1] * rhs.f_[12] + f_[5] * rhs.f_[13] + f_[9] * rhs.f_[14] +
+               f_[13] * rhs.f_[15];
+  ret.f_[14] = f_[2] * rhs.f_[12] + f_[6] * rhs.f_[13] + f_[10] * rhs.f_[14] +
+               f_[14] * rhs.f_[15];
+  ret.f_[15] = f_[3] * rhs.f_[12] + f_[7] * rhs.f_[13] + f_[11] * rhs.f_[14] +
+               f_[15] * rhs.f_[15];
+
+  return ret;
+}
+
+Vec4 Mat4::operator*(const Vec4& rhs) const {
+  Vec4 ret;
+  ret.x_ = rhs.x_ * f_[0] + rhs.y_ * f_[4] + rhs.z_ * f_[8] + rhs.w_ * f_[12];
+  ret.y_ = rhs.x_ * f_[1] + rhs.y_ * f_[5] + rhs.z_ * f_[9] + rhs.w_ * f_[13];
+  ret.z_ = rhs.x_ * f_[2] + rhs.y_ * f_[6] + rhs.z_ * f_[10] + rhs.w_ * f_[14];
+  ret.w_ = rhs.x_ * f_[3] + rhs.y_ * f_[7] + rhs.z_ * f_[11] + rhs.w_ * f_[15];
+  return ret;
+}
+
+Mat4 Mat4::Inverse() {
+  Mat4 ret;
+  float det_1;
+  float pos = 0;
+  float neg = 0;
+  float temp;
+
+  temp = f_[0] * f_[5] * f_[10];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  temp = f_[4] * f_[9] * f_[2];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  temp = f_[8] * f_[1] * f_[6];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  temp = -f_[8] * f_[5] * f_[2];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  temp = -f_[4] * f_[1] * f_[10];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  temp = -f_[0] * f_[9] * f_[6];
+  if (temp >= 0)
+    pos += temp;
+  else
+    neg += temp;
+  det_1 = pos + neg;
+
+  if (det_1 == 0.0) {
+    // Error
+  } else {
+    det_1 = 1.0f / det_1;
+    ret.f_[0] = (f_[5] * f_[10] - f_[9] * f_[6]) * det_1;
+    ret.f_[1] = -(f_[1] * f_[10] - f_[9] * f_[2]) * det_1;
+    ret.f_[2] = (f_[1] * f_[6] - f_[5] * f_[2]) * det_1;
+    ret.f_[4] = -(f_[4] * f_[10] - f_[8] * f_[6]) * det_1;
+    ret.f_[5] = (f_[0] * f_[10] - f_[8] * f_[2]) * det_1;
+    ret.f_[6] = -(f_[0] * f_[6] - f_[4] * f_[2]) * det_1;
+    ret.f_[8] = (f_[4] * f_[9] - f_[8] * f_[5]) * det_1;
+    ret.f_[9] = -(f_[0] * f_[9] - f_[8] * f_[1]) * det_1;
+    ret.f_[10] = (f_[0] * f_[5] - f_[4] * f_[1]) * det_1;
+
+    /* Calculate -C * inverse(A) */
+    ret.f_[12] =
+        -(f_[12] * ret.f_[0] + f_[13] * ret.f_[4] + f_[14] * ret.f_[8]);
+    ret.f_[13] =
+        -(f_[12] * ret.f_[1] + f_[13] * ret.f_[5] + f_[14] * ret.f_[9]);
+    ret.f_[14] =
+        -(f_[12] * ret.f_[2] + f_[13] * ret.f_[6] + f_[14] * ret.f_[10]);
+
+    ret.f_[3] = 0.0f;
+    ret.f_[7] = 0.0f;
+    ret.f_[11] = 0.0f;
+    ret.f_[15] = 1.0f;
+  }
+
+  *this = ret;
+  return *this;
+}
+
+//--------------------------------------------------------------------------------
+// Misc
+//--------------------------------------------------------------------------------
+Mat4 Mat4::RotationX(const float fAngle) {
+  Mat4 ret;
+  float fCosine, fSine;
+
+  fCosine = cosf(fAngle);
+  fSine = sinf(fAngle);
+
+  ret.f_[0] = 1.0f;
+  ret.f_[4] = 0.0f;
+  ret.f_[8] = 0.0f;
+  ret.f_[12] = 0.0f;
+  ret.f_[1] = 0.0f;
+  ret.f_[5] = fCosine;
+  ret.f_[9] = fSine;
+  ret.f_[13] = 0.0f;
+  ret.f_[2] = 0.0f;
+  ret.f_[6] = -fSine;
+  ret.f_[10] = fCosine;
+  ret.f_[14] = 0.0f;
+  ret.f_[3] = 0.0f;
+  ret.f_[7] = 0.0f;
+  ret.f_[11] = 0.0f;
+  ret.f_[15] = 1.0f;
+  return ret;
+}
+
+Mat4 Mat4::RotationY(const float fAngle) {
+  Mat4 ret;
+  float fCosine, fSine;
+
+  fCosine = cosf(fAngle);
+  fSine = sinf(fAngle);
+
+  ret.f_[0] = fCosine;
+  ret.f_[4] = 0.0f;
+  ret.f_[8] = -fSine;
+  ret.f_[12] = 0.0f;
+  ret.f_[1] = 0.0f;
+  ret.f_[5] = 1.0f;
+  ret.f_[9] = 0.0f;
+  ret.f_[13] = 0.0f;
+  ret.f_[2] = fSine;
+  ret.f_[6] = 0.0f;
+  ret.f_[10] = fCosine;
+  ret.f_[14] = 0.0f;
+  ret.f_[3] = 0.0f;
+  ret.f_[7] = 0.0f;
+  ret.f_[11] = 0.0f;
+  ret.f_[15] = 1.0f;
+  return ret;
+}
+
+Mat4 Mat4::RotationZ(const float fAngle) {
+  Mat4 ret;
+  float fCosine, fSine;
+
+  fCosine = cosf(fAngle);
+  fSine = sinf(fAngle);
+
+  ret.f_[0] = fCosine;
+  ret.f_[4] = fSine;
+  ret.f_[8] = 0.0f;
+  ret.f_[12] = 0.0f;
+  ret.f_[1] = -fSine;
+  ret.f_[5] = fCosine;
+  ret.f_[9] = 0.0f;
+  ret.f_[13] = 0.0f;
+  ret.f_[2] = 0.0f;
+  ret.f_[6] = 0.0f;
+  ret.f_[10] = 1.0f;
+  ret.f_[14] = 0.0f;
+  ret.f_[3] = 0.0f;
+  ret.f_[7] = 0.0f;
+  ret.f_[11] = 0.0f;
+  ret.f_[15] = 1.0f;
+  return ret;
+}
+
+Mat4 Mat4::Translation(const float fX, const float fY, const float fZ) {
+  Mat4 ret;
+  ret.f_[0] = 1.0f;
+  ret.f_[4] = 0.0f;
+  ret.f_[8] = 0.0f;
+  ret.f_[12] = fX;
+  ret.f_[1] = 0.0f;
+  ret.f_[5] = 1.0f;
+  ret.f_[9] = 0.0f;
+  ret.f_[13] = fY;
+  ret.f_[2] = 0.0f;
+  ret.f_[6] = 0.0f;
+  ret.f_[10] = 1.0f;
+  ret.f_[14] = fZ;
+  ret.f_[3] = 0.0f;
+  ret.f_[7] = 0.0f;
+  ret.f_[11] = 0.0f;
+  ret.f_[15] = 1.0f;
+  return ret;
+}
+
+Mat4 Mat4::Translation(const Vec3 vec) {
+  Mat4 ret;
+  ret.f_[0] = 1.0f;
+  ret.f_[4] = 0.0f;
+  ret.f_[8] = 0.0f;
+  ret.f_[12] = vec.x_;
+  ret.f_[1] = 0.0f;
+  ret.f_[5] = 1.0f;
+  ret.f_[9] = 0.0f;
+  ret.f_[13] = vec.y_;
+  ret.f_[2] = 0.0f;
+  ret.f_[6] = 0.0f;
+  ret.f_[10] = 1.0f;
+  ret.f_[14] = vec.z_;
+  ret.f_[3] = 0.0f;
+  ret.f_[7] = 0.0f;
+  ret.f_[11] = 0.0f;
+  ret.f_[15] = 1.0f;
+  return ret;
+}
+
+Mat4 Mat4::Perspective(float width, float height, float nearPlane,
+                       float farPlane) {
+  float n2 = 2.0f * nearPlane;
+  float rcpnmf = 1.f / (nearPlane - farPlane);
+
+  Mat4 result;
+  result.f_[0] = n2 / width;
+  result.f_[4] = 0;
+  result.f_[8] = 0;
+  result.f_[12] = 0;
+  result.f_[1] = 0;
+  result.f_[5] = n2 / height;
+  result.f_[9] = 0;
+  result.f_[13] = 0;
+  result.f_[2] = 0;
+  result.f_[6] = 0;
+  result.f_[10] = (farPlane + nearPlane) * rcpnmf;
+  result.f_[14] = farPlane * rcpnmf * n2;
+  result.f_[3] = 0;
+  result.f_[7] = 0;
+  result.f_[11] = -1.0;
+  result.f_[15] = 0;
+
+  return result;
+}
+
+Mat4 Mat4::LookAt(const Vec3& vec_eye, const Vec3& vec_at, const Vec3& vec_up) {
+  Vec3 vec_forward, vec_up_norm, vec_side;
+  Mat4 result;
+
+  vec_forward.x_ = vec_eye.x_ - vec_at.x_;
+  vec_forward.y_ = vec_eye.y_ - vec_at.y_;
+  vec_forward.z_ = vec_eye.z_ - vec_at.z_;
+
+  vec_forward.Normalize();
+  vec_up_norm = vec_up;
+  vec_up_norm.Normalize();
+  vec_side = vec_up_norm.Cross(vec_forward);
+  vec_up_norm = vec_forward.Cross(vec_side);
+
+  result.f_[0] = vec_side.x_;
+  result.f_[4] = vec_side.y_;
+  result.f_[8] = vec_side.z_;
+  result.f_[12] = 0;
+  result.f_[1] = vec_up_norm.x_;
+  result.f_[5] = vec_up_norm.y_;
+  result.f_[9] = vec_up_norm.z_;
+  result.f_[13] = 0;
+  result.f_[2] = vec_forward.x_;
+  result.f_[6] = vec_forward.y_;
+  result.f_[10] = vec_forward.z_;
+  result.f_[14] = 0;
+  result.f_[3] = 0;
+  result.f_[7] = 0;
+  result.f_[11] = 0;
+  result.f_[15] = 1.0;
+
+  result.PostTranslate(-vec_eye.x_, -vec_eye.y_, -vec_eye.z_);
+  return result;
+}
+
+}  // namespace ndkHelper

Teapot/app/src/main/jni/ndk_helper/vecmath.h

@@ -0,0 +1,959 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 VECMATH_H_
+#define VECMATH_H_
+
+#include <math.h>
+#include "JNIHelper.h"
+
+namespace ndk_helper {
+
+/******************************************************************
+ * Helper class for vector math operations
+ * Currently all implementations are in pure C++.
+ * Each class is an opaque class so caller does not have a direct access
+ * to each element. This is for an ease of future optimization to use vector
+ *operations.
+ *
+ */
+
+class Vec2;
+class Vec3;
+class Vec4;
+class Mat4;
+
+/******************************************************************
+ * 2 elements vector class
+ *
+ */
+class Vec2 {
+ private:
+  float x_;
+  float y_;
+
+ public:
+  friend class Vec3;
+  friend class Vec4;
+  friend class Mat4;
+  friend class Quaternion;
+
+  Vec2() { x_ = y_ = 0.f; }
+
+  Vec2(const float fX, const float fY) {
+    x_ = fX;
+    y_ = fY;
+  }
+
+  Vec2(const Vec2& vec) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+  }
+
+  Vec2(const float* pVec) {
+    x_ = (*pVec++);
+    y_ = (*pVec++);
+  }
+
+  // Operators
+  Vec2 operator*(const Vec2& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ * rhs.x_;
+    ret.y_ = y_ * rhs.y_;
+    return ret;
+  }
+
+  Vec2 operator/(const Vec2& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ / rhs.x_;
+    ret.y_ = y_ / rhs.y_;
+    return ret;
+  }
+
+  Vec2 operator+(const Vec2& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ + rhs.x_;
+    ret.y_ = y_ + rhs.y_;
+    return ret;
+  }
+
+  Vec2 operator-(const Vec2& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ - rhs.x_;
+    ret.y_ = y_ - rhs.y_;
+    return ret;
+  }
+
+  Vec2& operator+=(const Vec2& rhs) {
+    x_ += rhs.x_;
+    y_ += rhs.y_;
+    return *this;
+  }
+
+  Vec2& operator-=(const Vec2& rhs) {
+    x_ -= rhs.x_;
+    y_ -= rhs.y_;
+    return *this;
+  }
+
+  Vec2& operator*=(const Vec2& rhs) {
+    x_ *= rhs.x_;
+    y_ *= rhs.y_;
+    return *this;
+  }
+
+  Vec2& operator/=(const Vec2& rhs) {
+    x_ /= rhs.x_;
+    y_ /= rhs.y_;
+    return *this;
+  }
+
+  // External operators
+  friend Vec2 operator-(const Vec2& rhs) { return Vec2(rhs) *= -1; }
+
+  friend Vec2 operator*(const float lhs, const Vec2& rhs) {
+    Vec2 ret;
+    ret.x_ = lhs * rhs.x_;
+    ret.y_ = lhs * rhs.y_;
+    return ret;
+  }
+
+  friend Vec2 operator/(const float lhs, const Vec2& rhs) {
+    Vec2 ret;
+    ret.x_ = lhs / rhs.x_;
+    ret.y_ = lhs / rhs.y_;
+    return ret;
+  }
+
+  // Operators with float
+  Vec2 operator*(const float& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ * rhs;
+    ret.y_ = y_ * rhs;
+    return ret;
+  }
+
+  Vec2& operator*=(const float& rhs) {
+    x_ = x_ * rhs;
+    y_ = y_ * rhs;
+    return *this;
+  }
+
+  Vec2 operator/(const float& rhs) const {
+    Vec2 ret;
+    ret.x_ = x_ / rhs;
+    ret.y_ = y_ / rhs;
+    return ret;
+  }
+
+  Vec2& operator/=(const float& rhs) {
+    x_ = x_ / rhs;
+    y_ = y_ / rhs;
+    return *this;
+  }
+
+  // Compare
+  bool operator==(const Vec2& rhs) const {
+    if (x_ != rhs.x_ || y_ != rhs.y_) return false;
+    return true;
+  }
+
+  bool operator!=(const Vec2& rhs) const {
+    if (x_ == rhs.x_) return false;
+
+    return true;
+  }
+
+  float Length() const { return sqrtf(x_ * x_ + y_ * y_); }
+
+  Vec2 Normalize() {
+    float len = Length();
+    x_ = x_ / len;
+    y_ = y_ / len;
+    return *this;
+  }
+
+  float Dot(const Vec2& rhs) { return x_ * rhs.x_ + y_ * rhs.y_; }
+
+  bool Validate() {
+    if (isnan(x_) || isnan(y_)) return false;
+    return true;
+  }
+
+  void Value(float& fX, float& fY) {
+    fX = x_;
+    fY = y_;
+  }
+
+  void Dump() { LOGI("Vec2 %f %f", x_, y_); }
+};
+
+/******************************************************************
+ * 3 elements vector class
+ *
+ */
+class Vec3 {
+ private:
+  float x_, y_, z_;
+
+ public:
+  friend class Vec4;
+  friend class Mat4;
+  friend class Quaternion;
+
+  Vec3() { x_ = y_ = z_ = 0.f; }
+
+  Vec3(const float fX, const float fY, const float fZ) {
+    x_ = fX;
+    y_ = fY;
+    z_ = fZ;
+  }
+
+  Vec3(const Vec3& vec) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+    z_ = vec.z_;
+  }
+
+  Vec3(const float* pVec) {
+    x_ = (*pVec++);
+    y_ = (*pVec++);
+    z_ = *pVec;
+  }
+
+  Vec3(const Vec2& vec, float f) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+    z_ = f;
+  }
+
+  Vec3(const Vec4& vec);
+
+  // Operators
+  Vec3 operator*(const Vec3& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ * rhs.x_;
+    ret.y_ = y_ * rhs.y_;
+    ret.z_ = z_ * rhs.z_;
+    return ret;
+  }
+
+  Vec3 operator/(const Vec3& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ / rhs.x_;
+    ret.y_ = y_ / rhs.y_;
+    ret.z_ = z_ / rhs.z_;
+    return ret;
+  }
+
+  Vec3 operator+(const Vec3& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ + rhs.x_;
+    ret.y_ = y_ + rhs.y_;
+    ret.z_ = z_ + rhs.z_;
+    return ret;
+  }
+
+  Vec3 operator-(const Vec3& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ - rhs.x_;
+    ret.y_ = y_ - rhs.y_;
+    ret.z_ = z_ - rhs.z_;
+    return ret;
+  }
+
+  Vec3& operator+=(const Vec3& rhs) {
+    x_ += rhs.x_;
+    y_ += rhs.y_;
+    z_ += rhs.z_;
+    return *this;
+  }
+
+  Vec3& operator-=(const Vec3& rhs) {
+    x_ -= rhs.x_;
+    y_ -= rhs.y_;
+    z_ -= rhs.z_;
+    return *this;
+  }
+
+  Vec3& operator*=(const Vec3& rhs) {
+    x_ *= rhs.x_;
+    y_ *= rhs.y_;
+    z_ *= rhs.z_;
+    return *this;
+  }
+
+  Vec3& operator/=(const Vec3& rhs) {
+    x_ /= rhs.x_;
+    y_ /= rhs.y_;
+    z_ /= rhs.z_;
+    return *this;
+  }
+
+  // External operators
+  friend Vec3 operator-(const Vec3& rhs) { return Vec3(rhs) *= -1; }
+
+  friend Vec3 operator*(const float lhs, const Vec3& rhs) {
+    Vec3 ret;
+    ret.x_ = lhs * rhs.x_;
+    ret.y_ = lhs * rhs.y_;
+    ret.z_ = lhs * rhs.z_;
+    return ret;
+  }
+
+  friend Vec3 operator/(const float lhs, const Vec3& rhs) {
+    Vec3 ret;
+    ret.x_ = lhs / rhs.x_;
+    ret.y_ = lhs / rhs.y_;
+    ret.z_ = lhs / rhs.z_;
+    return ret;
+  }
+
+  // Operators with float
+  Vec3 operator*(const float& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ * rhs;
+    ret.y_ = y_ * rhs;
+    ret.z_ = z_ * rhs;
+    return ret;
+  }
+
+  Vec3& operator*=(const float& rhs) {
+    x_ = x_ * rhs;
+    y_ = y_ * rhs;
+    z_ = z_ * rhs;
+    return *this;
+  }
+
+  Vec3 operator/(const float& rhs) const {
+    Vec3 ret;
+    ret.x_ = x_ / rhs;
+    ret.y_ = y_ / rhs;
+    ret.z_ = z_ / rhs;
+    return ret;
+  }
+
+  Vec3& operator/=(const float& rhs) {
+    x_ = x_ / rhs;
+    y_ = y_ / rhs;
+    z_ = z_ / rhs;
+    return *this;
+  }
+
+  // Compare
+  bool operator==(const Vec3& rhs) const {
+    if (x_ != rhs.x_ || y_ != rhs.y_ || z_ != rhs.z_) return false;
+    return true;
+  }
+
+  bool operator!=(const Vec3& rhs) const {
+    if (x_ == rhs.x_) return false;
+
+    return true;
+  }
+
+  float Length() const { return sqrtf(x_ * x_ + y_ * y_ + z_ * z_); }
+
+  Vec3 Normalize() {
+    float len = Length();
+    x_ = x_ / len;
+    y_ = y_ / len;
+    z_ = z_ / len;
+    return *this;
+  }
+
+  float Dot(const Vec3& rhs) { return x_ * rhs.x_ + y_ * rhs.y_ + z_ * rhs.z_; }
+
+  Vec3 Cross(const Vec3& rhs) {
+    Vec3 ret;
+    ret.x_ = y_ * rhs.z_ - z_ * rhs.y_;
+    ret.y_ = z_ * rhs.x_ - x_ * rhs.z_;
+    ret.z_ = x_ * rhs.y_ - y_ * rhs.x_;
+    return ret;
+  }
+
+  bool Validate() {
+    if (isnan(x_) || isnan(y_) || isnan(z_)) return false;
+    return true;
+  }
+
+  void Value(float& fX, float& fY, float& fZ) {
+    fX = x_;
+    fY = y_;
+    fZ = z_;
+  }
+
+  void Dump() { LOGI("Vec3 %f %f %f", x_, y_, z_); }
+};
+
+/******************************************************************
+ * 4 elements vector class
+ *
+ */
+class Vec4 {
+ private:
+  float x_, y_, z_, w_;
+
+ public:
+  friend class Vec3;
+  friend class Mat4;
+  friend class Quaternion;
+
+  Vec4() { x_ = y_ = z_ = w_ = 0.f; }
+
+  Vec4(const float fX, const float fY, const float fZ, const float fW) {
+    x_ = fX;
+    y_ = fY;
+    z_ = fZ;
+    w_ = fW;
+  }
+
+  Vec4(const Vec4& vec) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+    z_ = vec.z_;
+    w_ = vec.w_;
+  }
+
+  Vec4(const Vec3& vec, const float fW) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+    z_ = vec.z_;
+    w_ = fW;
+  }
+
+  Vec4(const float* pVec) {
+    x_ = (*pVec++);
+    y_ = (*pVec++);
+    z_ = *pVec;
+    w_ = *pVec;
+  }
+
+  // Operators
+  Vec4 operator*(const Vec4& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ * rhs.x_;
+    ret.y_ = y_ * rhs.y_;
+    ret.z_ = z_ * rhs.z_;
+    ret.w_ = z_ * rhs.w_;
+    return ret;
+  }
+
+  Vec4 operator/(const Vec4& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ / rhs.x_;
+    ret.y_ = y_ / rhs.y_;
+    ret.z_ = z_ / rhs.z_;
+    ret.w_ = z_ / rhs.w_;
+    return ret;
+  }
+
+  Vec4 operator+(const Vec4& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ + rhs.x_;
+    ret.y_ = y_ + rhs.y_;
+    ret.z_ = z_ + rhs.z_;
+    ret.w_ = z_ + rhs.w_;
+    return ret;
+  }
+
+  Vec4 operator-(const Vec4& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ - rhs.x_;
+    ret.y_ = y_ - rhs.y_;
+    ret.z_ = z_ - rhs.z_;
+    ret.w_ = z_ - rhs.w_;
+    return ret;
+  }
+
+  Vec4& operator+=(const Vec4& rhs) {
+    x_ += rhs.x_;
+    y_ += rhs.y_;
+    z_ += rhs.z_;
+    w_ += rhs.w_;
+    return *this;
+  }
+
+  Vec4& operator-=(const Vec4& rhs) {
+    x_ -= rhs.x_;
+    y_ -= rhs.y_;
+    z_ -= rhs.z_;
+    w_ -= rhs.w_;
+    return *this;
+  }
+
+  Vec4& operator*=(const Vec4& rhs) {
+    x_ *= rhs.x_;
+    y_ *= rhs.y_;
+    z_ *= rhs.z_;
+    w_ *= rhs.w_;
+    return *this;
+  }
+
+  Vec4& operator/=(const Vec4& rhs) {
+    x_ /= rhs.x_;
+    y_ /= rhs.y_;
+    z_ /= rhs.z_;
+    w_ /= rhs.w_;
+    return *this;
+  }
+
+  // External operators
+  friend Vec4 operator-(const Vec4& rhs) { return Vec4(rhs) *= -1; }
+
+  friend Vec4 operator*(const float lhs, const Vec4& rhs) {
+    Vec4 ret;
+    ret.x_ = lhs * rhs.x_;
+    ret.y_ = lhs * rhs.y_;
+    ret.z_ = lhs * rhs.z_;
+    ret.w_ = lhs * rhs.w_;
+    return ret;
+  }
+
+  friend Vec4 operator/(const float lhs, const Vec4& rhs) {
+    Vec4 ret;
+    ret.x_ = lhs / rhs.x_;
+    ret.y_ = lhs / rhs.y_;
+    ret.z_ = lhs / rhs.z_;
+    ret.w_ = lhs / rhs.w_;
+    return ret;
+  }
+
+  // Operators with float
+  Vec4 operator*(const float& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ * rhs;
+    ret.y_ = y_ * rhs;
+    ret.z_ = z_ * rhs;
+    ret.w_ = w_ * rhs;
+    return ret;
+  }
+
+  Vec4& operator*=(const float& rhs) {
+    x_ = x_ * rhs;
+    y_ = y_ * rhs;
+    z_ = z_ * rhs;
+    w_ = w_ * rhs;
+    return *this;
+  }
+
+  Vec4 operator/(const float& rhs) const {
+    Vec4 ret;
+    ret.x_ = x_ / rhs;
+    ret.y_ = y_ / rhs;
+    ret.z_ = z_ / rhs;
+    ret.w_ = w_ / rhs;
+    return ret;
+  }
+
+  Vec4& operator/=(const float& rhs) {
+    x_ = x_ / rhs;
+    y_ = y_ / rhs;
+    z_ = z_ / rhs;
+    w_ = w_ / rhs;
+    return *this;
+  }
+
+  // Compare
+  bool operator==(const Vec4& rhs) const {
+    if (x_ != rhs.x_ || y_ != rhs.y_ || z_ != rhs.z_ || w_ != rhs.w_)
+      return false;
+    return true;
+  }
+
+  bool operator!=(const Vec4& rhs) const {
+    if (x_ == rhs.x_) return false;
+
+    return true;
+  }
+
+  Vec4 operator*(const Mat4& rhs) const;
+
+  float Length() const { return sqrtf(x_ * x_ + y_ * y_ + z_ * z_ + w_ * w_); }
+
+  Vec4 Normalize() {
+    float len = Length();
+    x_ = x_ / len;
+    y_ = y_ / len;
+    z_ = z_ / len;
+    w_ = w_ / len;
+    return *this;
+  }
+
+  float Dot(const Vec3& rhs) { return x_ * rhs.x_ + y_ * rhs.y_ + z_ * rhs.z_; }
+
+  Vec3 Cross(const Vec3& rhs) {
+    Vec3 ret;
+    ret.x_ = y_ * rhs.z_ - z_ * rhs.y_;
+    ret.y_ = z_ * rhs.x_ - x_ * rhs.z_;
+    ret.z_ = x_ * rhs.y_ - y_ * rhs.x_;
+    return ret;
+  }
+
+  bool Validate() {
+    if (isnan(x_) || isnan(y_) || isnan(z_) || isnan(w_)) return false;
+    return true;
+  }
+
+  void Value(float& fX, float& fY, float& fZ, float& fW) {
+    fX = x_;
+    fY = y_;
+    fZ = z_;
+    fW = w_;
+  }
+};
+
+/******************************************************************
+ * 4x4 matrix
+ *
+ */
+class Mat4 {
+ private:
+  float f_[16];
+
+ public:
+  friend class Vec3;
+  friend class Vec4;
+  friend class Quaternion;
+
+  Mat4();
+  Mat4(const float*);
+
+  Mat4 operator*(const Mat4& rhs) const;
+  Vec4 operator*(const Vec4& rhs) const;
+
+  Mat4 operator+(const Mat4& rhs) const {
+    Mat4 ret;
+    for (int32_t i = 0; i < 16; ++i) {
+      ret.f_[i] = f_[i] + rhs.f_[i];
+    }
+    return ret;
+  }
+
+  Mat4 operator-(const Mat4& rhs) const {
+    Mat4 ret;
+    for (int32_t i = 0; i < 16; ++i) {
+      ret.f_[i] = f_[i] - rhs.f_[i];
+    }
+    return ret;
+  }
+
+  Mat4& operator+=(const Mat4& rhs) {
+    for (int32_t i = 0; i < 16; ++i) {
+      f_[i] += rhs.f_[i];
+    }
+    return *this;
+  }
+
+  Mat4& operator-=(const Mat4& rhs) {
+    for (int32_t i = 0; i < 16; ++i) {
+      f_[i] -= rhs.f_[i];
+    }
+    return *this;
+  }
+
+  Mat4& operator*=(const Mat4& rhs) {
+    Mat4 ret;
+    ret.f_[0] = f_[0] * rhs.f_[0] + f_[4] * rhs.f_[1] + f_[8] * rhs.f_[2] +
+                f_[12] * rhs.f_[3];
+    ret.f_[1] = f_[1] * rhs.f_[0] + f_[5] * rhs.f_[1] + f_[9] * rhs.f_[2] +
+                f_[13] * rhs.f_[3];
+    ret.f_[2] = f_[2] * rhs.f_[0] + f_[6] * rhs.f_[1] + f_[10] * rhs.f_[2] +
+                f_[14] * rhs.f_[3];
+    ret.f_[3] = f_[3] * rhs.f_[0] + f_[7] * rhs.f_[1] + f_[11] * rhs.f_[2] +
+                f_[15] * rhs.f_[3];
+
+    ret.f_[4] = f_[0] * rhs.f_[4] + f_[4] * rhs.f_[5] + f_[8] * rhs.f_[6] +
+                f_[12] * rhs.f_[7];
+    ret.f_[5] = f_[1] * rhs.f_[4] + f_[5] * rhs.f_[5] + f_[9] * rhs.f_[6] +
+                f_[13] * rhs.f_[7];
+    ret.f_[6] = f_[2] * rhs.f_[4] + f_[6] * rhs.f_[5] + f_[10] * rhs.f_[6] +
+                f_[14] * rhs.f_[7];
+    ret.f_[7] = f_[3] * rhs.f_[4] + f_[7] * rhs.f_[5] + f_[11] * rhs.f_[6] +
+                f_[15] * rhs.f_[7];
+
+    ret.f_[8] = f_[0] * rhs.f_[8] + f_[4] * rhs.f_[9] + f_[8] * rhs.f_[10] +
+                f_[12] * rhs.f_[11];
+    ret.f_[9] = f_[1] * rhs.f_[8] + f_[5] * rhs.f_[9] + f_[9] * rhs.f_[10] +
+                f_[13] * rhs.f_[11];
+    ret.f_[10] = f_[2] * rhs.f_[8] + f_[6] * rhs.f_[9] + f_[10] * rhs.f_[10] +
+                 f_[14] * rhs.f_[11];
+    ret.f_[11] = f_[3] * rhs.f_[8] + f_[7] * rhs.f_[9] + f_[11] * rhs.f_[10] +
+                 f_[15] * rhs.f_[11];
+
+    ret.f_[12] = f_[0] * rhs.f_[12] + f_[4] * rhs.f_[13] + f_[8] * rhs.f_[14] +
+                 f_[12] * rhs.f_[15];
+    ret.f_[13] = f_[1] * rhs.f_[12] + f_[5] * rhs.f_[13] + f_[9] * rhs.f_[14] +
+                 f_[13] * rhs.f_[15];
+    ret.f_[14] = f_[2] * rhs.f_[12] + f_[6] * rhs.f_[13] + f_[10] * rhs.f_[14] +
+                 f_[14] * rhs.f_[15];
+    ret.f_[15] = f_[3] * rhs.f_[12] + f_[7] * rhs.f_[13] + f_[11] * rhs.f_[14] +
+                 f_[15] * rhs.f_[15];
+
+    *this = ret;
+    return *this;
+  }
+
+  Mat4 operator*(const float rhs) {
+    Mat4 ret;
+    for (int32_t i = 0; i < 16; ++i) {
+      ret.f_[i] = f_[i] * rhs;
+    }
+    return ret;
+  }
+
+  Mat4& operator*=(const float rhs) {
+    for (int32_t i = 0; i < 16; ++i) {
+      f_[i] *= rhs;
+    }
+    return *this;
+  }
+
+  Mat4& operator=(const Mat4& rhs) {
+    for (int32_t i = 0; i < 16; ++i) {
+      f_[i] = rhs.f_[i];
+    }
+    return *this;
+  }
+
+  Mat4 Inverse();
+
+  Mat4 Transpose() {
+    Mat4 ret;
+    ret.f_[0] = f_[0];
+    ret.f_[1] = f_[4];
+    ret.f_[2] = f_[8];
+    ret.f_[3] = f_[12];
+    ret.f_[4] = f_[1];
+    ret.f_[5] = f_[5];
+    ret.f_[6] = f_[9];
+    ret.f_[7] = f_[13];
+    ret.f_[8] = f_[2];
+    ret.f_[9] = f_[6];
+    ret.f_[10] = f_[10];
+    ret.f_[11] = f_[14];
+    ret.f_[12] = f_[3];
+    ret.f_[13] = f_[7];
+    ret.f_[14] = f_[11];
+    ret.f_[15] = f_[15];
+    *this = ret;
+    return *this;
+  }
+
+  Mat4& PostTranslate(float tx, float ty, float tz) {
+    f_[12] += (tx * f_[0]) + (ty * f_[4]) + (tz * f_[8]);
+    f_[13] += (tx * f_[1]) + (ty * f_[5]) + (tz * f_[9]);
+    f_[14] += (tx * f_[2]) + (ty * f_[6]) + (tz * f_[10]);
+    f_[15] += (tx * f_[3]) + (ty * f_[7]) + (tz * f_[11]);
+    return *this;
+  }
+
+  float* Ptr() { return f_; }
+
+  //--------------------------------------------------------------------------------
+  // Misc
+  //--------------------------------------------------------------------------------
+  static Mat4 Perspective(float width, float height, float nearPlane,
+                          float farPlane);
+
+  static Mat4 LookAt(const Vec3& vEye, const Vec3& vAt, const Vec3& vUp);
+
+  static Mat4 Translation(const float fX, const float fY, const float fZ);
+  static Mat4 Translation(const Vec3 vec);
+
+  static Mat4 RotationX(const float angle);
+
+  static Mat4 RotationY(const float angle);
+
+  static Mat4 RotationZ(const float angle);
+
+  static Mat4 Identity() {
+    Mat4 ret;
+    ret.f_[0] = 1.f;
+    ret.f_[1] = 0;
+    ret.f_[2] = 0;
+    ret.f_[3] = 0;
+    ret.f_[4] = 0;
+    ret.f_[5] = 1.f;
+    ret.f_[6] = 0;
+    ret.f_[7] = 0;
+    ret.f_[8] = 0;
+    ret.f_[9] = 0;
+    ret.f_[10] = 1.f;
+    ret.f_[11] = 0;
+    ret.f_[12] = 0;
+    ret.f_[13] = 0;
+    ret.f_[14] = 0;
+    ret.f_[15] = 1.f;
+    return ret;
+  }
+
+  void Dump() {
+    LOGI("%f %f %f %f", f_[0], f_[1], f_[2], f_[3]);
+    LOGI("%f %f %f %f", f_[4], f_[5], f_[6], f_[7]);
+    LOGI("%f %f %f %f", f_[8], f_[9], f_[10], f_[11]);
+    LOGI("%f %f %f %f", f_[12], f_[13], f_[14], f_[15]);
+  }
+};
+
+/******************************************************************
+ * Quaternion class
+ *
+ */
+class Quaternion {
+ private:
+  float x_, y_, z_, w_;
+
+ public:
+  friend class Vec3;
+  friend class Vec4;
+  friend class Mat4;
+
+  Quaternion() {
+    x_ = 0.f;
+    y_ = 0.f;
+    z_ = 0.f;
+    w_ = 1.f;
+  }
+
+  Quaternion(const float fX, const float fY, const float fZ, const float fW) {
+    x_ = fX;
+    y_ = fY;
+    z_ = fZ;
+    w_ = fW;
+  }
+
+  Quaternion(const Vec3 vec, const float fW) {
+    x_ = vec.x_;
+    y_ = vec.y_;
+    z_ = vec.z_;
+    w_ = fW;
+  }
+
+  Quaternion(const float* p) {
+    x_ = *p++;
+    y_ = *p++;
+    z_ = *p++;
+    w_ = *p++;
+  }
+
+  Quaternion operator*(const Quaternion rhs) {
+    Quaternion ret;
+    ret.x_ = x_ * rhs.w_ + y_ * rhs.z_ - z_ * rhs.y_ + w_ * rhs.x_;
+    ret.y_ = -x_ * rhs.z_ + y_ * rhs.w_ + z_ * rhs.x_ + w_ * rhs.y_;
+    ret.z_ = x_ * rhs.y_ - y_ * rhs.x_ + z_ * rhs.w_ + w_ * rhs.z_;
+    ret.w_ = -x_ * rhs.x_ - y_ * rhs.y_ - z_ * rhs.z_ + w_ * rhs.w_;
+    return ret;
+  }
+
+  Quaternion& operator*=(const Quaternion rhs) {
+    Quaternion ret;
+    ret.x_ = x_ * rhs.w_ + y_ * rhs.z_ - z_ * rhs.y_ + w_ * rhs.x_;
+    ret.y_ = -x_ * rhs.z_ + y_ * rhs.w_ + z_ * rhs.x_ + w_ * rhs.y_;
+    ret.z_ = x_ * rhs.y_ - y_ * rhs.x_ + z_ * rhs.w_ + w_ * rhs.z_;
+    ret.w_ = -x_ * rhs.x_ - y_ * rhs.y_ - z_ * rhs.z_ + w_ * rhs.w_;
+    *this = ret;
+    return *this;
+  }
+
+  Quaternion Conjugate() {
+    x_ = -x_;
+    y_ = -y_;
+    z_ = -z_;
+    return *this;
+  }
+
+  // Non destuctive version
+  Quaternion Conjugated() {
+    Quaternion ret;
+    ret.x_ = -x_;
+    ret.y_ = -y_;
+    ret.z_ = -z_;
+    ret.w_ = w_;
+    return ret;
+  }
+
+  void ToMatrix(Mat4& mat) {
+    float x2 = x_ * x_ * 2.0f;
+    float y2 = y_ * y_ * 2.0f;
+    float z2 = z_ * z_ * 2.0f;
+    float xy = x_ * y_ * 2.0f;
+    float yz = y_ * z_ * 2.0f;
+    float zx = z_ * x_ * 2.0f;
+    float xw = x_ * w_ * 2.0f;
+    float yw = y_ * w_ * 2.0f;
+    float zw = z_ * w_ * 2.0f;
+
+    mat.f_[0] = 1.0f - y2 - z2;
+    mat.f_[1] = xy + zw;
+    mat.f_[2] = zx - yw;
+    mat.f_[4] = xy - zw;
+    mat.f_[5] = 1.0f - z2 - x2;
+    mat.f_[6] = yz + xw;
+    mat.f_[8] = zx + yw;
+    mat.f_[9] = yz - xw;
+    mat.f_[10] = 1.0f - x2 - y2;
+
+    mat.f_[3] = mat.f_[7] = mat.f_[11] = mat.f_[12] = mat.f_[13] = mat.f_[14] =
+        0.0f;
+    mat.f_[15] = 1.0f;
+  }
+
+  void ToMatrixPreserveTranslate(Mat4& mat) {
+    float x2 = x_ * x_ * 2.0f;
+    float y2 = y_ * y_ * 2.0f;
+    float z2 = z_ * z_ * 2.0f;
+    float xy = x_ * y_ * 2.0f;
+    float yz = y_ * z_ * 2.0f;
+    float zx = z_ * x_ * 2.0f;
+    float xw = x_ * w_ * 2.0f;
+    float yw = y_ * w_ * 2.0f;
+    float zw = z_ * w_ * 2.0f;
+
+    mat.f_[0] = 1.0f - y2 - z2;
+    mat.f_[1] = xy + zw;
+    mat.f_[2] = zx - yw;
+    mat.f_[4] = xy - zw;
+    mat.f_[5] = 1.0f - z2 - x2;
+    mat.f_[6] = yz + xw;
+    mat.f_[8] = zx + yw;
+    mat.f_[9] = yz - xw;
+    mat.f_[10] = 1.0f - x2 - y2;
+
+    mat.f_[3] = mat.f_[7] = mat.f_[11] = 0.0f;
+    mat.f_[15] = 1.0f;
+  }
+
+  static Quaternion RotationAxis(const Vec3 axis, const float angle) {
+    Quaternion ret;
+    float s = sinf(angle / 2);
+    ret.x_ = s * axis.x_;
+    ret.y_ = s * axis.y_;
+    ret.z_ = s * axis.z_;
+    ret.w_ = cosf(angle / 2);
+    return ret;
+  }
+
+  void Value(float& fX, float& fY, float& fZ, float& fW) {
+    fX = x_;
+    fY = y_;
+    fZ = z_;
+    fW = w_;
+  }
+};
+
+}  // namespace ndk_helper
+#endif /* VECMATH_H_ */