LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleaned code, added pinch gesture detector, better opengl context handling, fixed issues

Browse Source 
Change-Id: I26a28374ae74391204586b4584d03cf0c58772c2
This commit is contained in:
Hak Matsuda
2013-09-26 20:58:00 -07:00
committed by Andrew Hsieh
parent 122d194b36
commit 5d1c91fb75
55 changed files with 6544 additions and 763 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ndk/platforms/android-17/samples/Teapot/assets/Shaders/ShaderPlain.fsh
View File

@@ -21,7 +21,7 @@ void main()
{
#if USE_PHONG
mediump vec3 halfVector = normalize(-vLight0 + position);
mediump float NdotH = max(dot(normal, halfVector), 0.0);
mediump float NdotH = max(dot(normalize(normal), halfVector), 0.0);
mediump float fPower = vMaterialSpecular.w;
mediump float specular = pow(NdotH, fPower);

11
ndk/platforms/android-17/samples/Teapot/jni/Android.mk
View File

@@ -5,21 +5,16 @@ include $(CLEAR_VARS)
LOCAL_MODULE := NativeActivity
LOCAL_SRC_FILES := TeapotNativeActivity.cpp \
TeapotRenderer.cpp \
NDKSupport/JNIHelper.cpp \
NDKSupport/shader.cpp \
NDKSupport/vecmath.cpp \
NDKSupport/gestureDetector.cpp \
NDKSupport/perfMonitor.cpp \
NDKSupport/tapCamera.cpp \
LOCAL_C_INCLUDES := $(LOCAL_PATH)/NDKSupport
LOCAL_C_INCLUDES :=
LOCAL_CFLAGS :=
LOCAL_LDLIBS := -llog -landroid -lEGL -lGLESv2
LOCAL_STATIC_LIBRARIES := cpufeatures android_native_app_glue
LOCAL_STATIC_LIBRARIES := cpufeatures android_native_app_glue helper
include $(BUILD_SHARED_LIBRARY)
$(call import-module,android/helper)
$(call import-module,android/native_app_glue)
$(call import-module,android/cpufeatures)

130
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/gestureDetector.cpp
View File

@@ -1,130 +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.
*/
//--------------------------------------------------------------------------------
// gestureDetector.cpp
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
// includes
//--------------------------------------------------------------------------------
#include "gestureDetector.h"
//--------------------------------------------------------------------------------
// GestureDetector
//--------------------------------------------------------------------------------
GestureDetector::GestureDetector()
{
_fDpFactor = 1.f;
}
void GestureDetector::setConfiguration(AConfiguration* config)
{
_fDpFactor = 160.f / AConfiguration_getDensity(config);
}
//--------------------------------------------------------------------------------
// TapDetector
//--------------------------------------------------------------------------------
bool TapDetector::detect(const AInputEvent* motion_event)
{
if( AMotionEvent_getPointerCount(motion_event) > 1 )
{
//Only support single touch
return false;
}
int32_t iAction = AMotionEvent_getAction(motion_event);
unsigned int flags = iAction & AMOTION_EVENT_ACTION_MASK;
switch( flags )
{
case AMOTION_EVENT_ACTION_DOWN:
_iDownPointerID = AMotionEvent_getPointerId(motion_event, 0);
_fDownX = AMotionEvent_getX(motion_event, 0);
_fDownY = 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( _iDownPointerID == AMotionEvent_getPointerId(motion_event, 0) )
{
float fX = AMotionEvent_getX(motion_event, 0) - _fDownX;
float fY = AMotionEvent_getY(motion_event, 0) - _fDownY;
if( fX * fX + fY * fY < TOUCH_SLOP * TOUCH_SLOP * _fDpFactor )
{
LOGI("TapDetector: Tap detected");
return true;
}
}
}
break;
}
}
return false;
}
//--------------------------------------------------------------------------------
// DoubletapDetector
//--------------------------------------------------------------------------------
bool DoubletapDetector::detect(const AInputEvent* motion_event)
{
if( AMotionEvent_getPointerCount(motion_event) > 1 )
{
//Only support single touch
return false;
}
bool bDetectedTap = _tapDetector.detect(motion_event);
int32_t iAction = AMotionEvent_getAction(motion_event);
unsigned int flags = iAction & AMOTION_EVENT_ACTION_MASK;
switch( flags )
{
case AMOTION_EVENT_ACTION_DOWN:
{
int64_t eventTime = AMotionEvent_getEventTime(motion_event);
if( eventTime - _lastTapTime <= DOUBLE_TAP_TIMEOUT )
{
float fX = AMotionEvent_getX(motion_event, 0) - _fLastTapX;
float fY = AMotionEvent_getY(motion_event, 0) - _fLastTapY;
if( fX * fX + fY * fY < DOUBLE_TAP_SLOP * DOUBLE_TAP_SLOP * _fDpFactor )
{
LOGI("DoubletapDetector: Doubletap detected");
return true;
}
}
break;
}
case AMOTION_EVENT_ACTION_UP:
if( bDetectedTap )
{
_lastTapTime = AMotionEvent_getEventTime(motion_event);
_fLastTapX = AMotionEvent_getX(motion_event, 0);
_fLastTapY = AMotionEvent_getY(motion_event, 0);
}
break;
}
return false;
}
void DoubletapDetector::setConfiguration(AConfiguration* config)
{
_fDpFactor = 160.f / AConfiguration_getDensity(config);
_tapDetector.setConfiguration(config);
}

76
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/gestureDetector.h
View File

@@ -1,76 +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.
*/
//--------------------------------------------------------------------------------
// gestureDetector.h
//--------------------------------------------------------------------------------
#ifndef GESTUREDETECTOR_H_
#define GESTUREDETECTOR_H_
#include <android/sensor.h>
#include <android/log.h>
#include <android_native_app_glue.h>
#include <android/native_window_jni.h>
#include "JNIHelper.h"
//--------------------------------------------------------------------------------
// 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;
class GestureDetector
{
protected:
float _fDpFactor;
public:
GestureDetector();
virtual ~GestureDetector() {}
virtual void setConfiguration(AConfiguration* config);
virtual bool detect(const AInputEvent* motion_event) = 0;
};
class TapDetector:public GestureDetector
{
int32_t _iDownPointerID;
float _fDownX;
float _fDownY;
public:
TapDetector() {}
virtual ~TapDetector() {}
virtual bool detect(const AInputEvent* motion_event);
};
class DoubletapDetector:public GestureDetector
{
TapDetector _tapDetector;
int64_t _lastTapTime;
float _fLastTapX;
float _fLastTapY;
public:
DoubletapDetector() {}
virtual ~DoubletapDetector() {}
virtual bool detect(const AInputEvent* motion_event);
virtual void setConfiguration(AConfiguration* config);
};
#endif /* GESTUREDETECTOR_H_ */

705
ndk/platforms/android-17/samples/Teapot/jni/TeapotNativeActivity.cpp
View File

@@ -21,6 +21,7 @@
#include <errno.h>
#include <vector>
#include <EGL/egl.h>
#include <GLES/gl.h>
@@ -30,173 +31,136 @@
#include <android/native_window_jni.h>
#include <cpu-features.h>
#include "NDKSupport/NDKSupport.h"
#include "TeapotRenderer.h"
#include "NDKHelper.h"
/**
* Our saved state data.
*/
struct saved_state {
float angle;
int32_t x;
int32_t y;
};
/**
* Shared state for our app.
*/
//-------------------------------------------------------------------------
//Shared state for our app.
//-------------------------------------------------------------------------
struct android_app;
class engine {
public:
struct android_app* app;
ASensorManager* sensorManager;
const ASensor* accelerometerSensor;
ASensorEventQueue* sensorEventQueue;
int animating;
EGLDisplay display;
EGLSurface surface;
EGLContext context;
int32_t width;
int32_t height;
struct saved_state state;
std::vector<int32_t> _vecPointers;
tapCamera _tapCamera;
TeapotRenderer _renderer;
GLContext* _glContext;
bool _bInitializedResources;
bool _bHasFocus;
DoubletapDetector _doubletapDetector;
PinchDetector _pinchDetector;
DragDetector _dragDetector;
perfMonitor _monitor;
tapCamera _tapCamera;
android_app* _app;
ASensorManager* _sensorManager;
const ASensor* _accelerometerSensor;
ASensorEventQueue* _sensorEventQueue;
void updateFPS(float fFPS);
void showUI();
void transformPosition( 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();
};
void showUI(android_app* app)
//-------------------------------------------------------------------------
//Ctor
//-------------------------------------------------------------------------
engine::engine() :
_bInitializedResources( false ),
_bHasFocus( false ),
_app( NULL ),
_sensorManager( NULL ),
_accelerometerSensor( NULL ),
_sensorEventQueue( NULL )
{
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;
_glContext = GLContext::getInstance();
}
void updateFPS(android_app* app, float fFPS)
//-------------------------------------------------------------------------
//Dtor
//-------------------------------------------------------------------------
engine::~engine()
{
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);
/**
* Load resources
*/
void engine::loadResources()
{
_renderer.init();
_renderer.bind(&_tapCamera);
}
app->activity->vm->DetachCurrentThread();
return;
/**
* Unload resources
*/
void engine::unloadResources()
{
_renderer.unload();
}
/**
* Initialize an EGL context for the current display.
*/
static int engine_init_display(struct engine* engine) {
// initialize OpenGL ES and EGL
showUI(engine->app);
const EGLint contextAttribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2, //Request opengl ES2.0
EGL_NONE
};
EGLint w, h, dummy, format;
EGLint numConfigs;
EGLConfig config;
EGLSurface surface;
EGLContext context;
EGLDisplay 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
};
eglChooseConfig(display, attribs, &config, 1, &numConfigs);
if( !numConfigs )
int engine::initDisplay()
{
if( !_bInitializedResources )
{
//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, &numConfigs);
_glContext->init( _app->window );
loadResources();
_bInitializedResources = true;
}
if ( !numConfigs )
else
{
LOGW("Unable to retrieve EGL config");
return -1;
// initialize OpenGL ES and EGL
if( EGL_SUCCESS != _glContext->resume( _app->window ) )
{
unloadResources();
loadResources();
}
}
/* EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is
* guaranteed to be accepted by ANativeWindow_setBuffersGeometry().
* As soon as we picked a EGLConfig, we can safely reconfigure the
* ANativeWindow buffers to match, using EGL_NATIVE_VISUAL_ID. */
eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);
ANativeWindow_setBuffersGeometry(engine->app->window, 0, 0, format);
surface = eglCreateWindowSurface(display, config, engine->app->window, NULL);
context = eglCreateContext(display, config, NULL, contextAttribs);
if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) {
LOGW("Unable to eglMakeCurrent");
return -1;
}
eglQuerySurface(display, surface, EGL_WIDTH, &w);
eglQuerySurface(display, surface, EGL_HEIGHT, &h);
engine->display = display;
engine->context = context;
engine->surface = surface;
engine->width = w;
engine->height = h;
engine->state.angle = 0;
showUI();
// Initialize GL state.
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glFrontFace(GL_CW);
glViewport(0, 0, engine->width, engine->height);
engine->_tapCamera.setFlip(1.f, -1.f, -8.f);
//Note that screen size might have been changed
glViewport(0, 0,
_glContext->getScreenWidth(),
_glContext->getScreenHeight() );
_renderer.updateViewport();
engine->_renderer.init();
engine->_renderer.bind(&engine->_tapCamera);
_tapCamera.setFlip(1.f, -1.f, -1.f);
_tapCamera.setPinchTransformFactor(2.f, 2.f, 8.f);
return 0;
}
@@ -204,201 +168,108 @@ static int engine_init_display(struct engine* engine) {
/**
* Just the current frame in the display.
*/
static void engine_draw_frame(struct engine* engine) {
if (engine->display == NULL) {
// No display.
return;
}
void engine::drawFrame()
{
float fFPS;
bool b = engine->_monitor.update(fFPS);
if( b )
if( _monitor.update(fFPS) )
{
updateFPS( engine->app, fFPS );
updateFPS( fFPS );
}
struct timeval Time;
gettimeofday( &Time, NULL );
double dTime = Time.tv_sec + Time.tv_usec * 1.0/1000000.0 ;
engine->_renderer.update(dTime);
double dTime = _monitor.getCurrentTime();
_renderer.update(dTime);
// Just fill the screen with a color.
glViewport(0, 0, engine->width, engine->height);
glClearColor(0.5f, 0.5f, 0.5f, 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
engine->_renderer.render();
_renderer.render();
eglSwapBuffers(engine->display, engine->surface);
// Swap
if( EGL_SUCCESS != _glContext->swap() )
{
unloadResources();
loadResources();
}
}
/**
* Tear down the EGL context currently associated with the display.
*/
static void engine_term_display(struct engine* engine) {
engine->_renderer.unload();
if (engine->display != EGL_NO_DISPLAY) {
eglMakeCurrent(engine->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
if (engine->context != EGL_NO_CONTEXT) {
eglDestroyContext(engine->display, engine->context);
}
if (engine->surface != EGL_NO_SURFACE) {
eglDestroySurface(engine->display, engine->surface);
}
eglTerminate(engine->display);
}
engine->animating = 0;
engine->display = EGL_NO_DISPLAY;
engine->context = EGL_NO_CONTEXT;
engine->surface = EGL_NO_SURFACE;
}
int32_t findIndex( AInputEvent* event, int32_t iID )
void engine::termDisplay()
{
int32_t iCount = AMotionEvent_getPointerCount(event);
for( int32_t i = 0; i < iCount; ++i )
{
if( iID == AMotionEvent_getPointerId(event, i) )
return i;
}
return -1;
_glContext->suspend();
}
void updatePosition( engine* engine, AInputEvent* event, int32_t iIndex, float& fX, float& fY)
void engine::trimMemory()
{
engine->state.x = AMotionEvent_getX(event, iIndex);
engine->state.y = AMotionEvent_getY(event, iIndex);
fX = 2.0f * engine->state.x / engine->width -1.f;
fY = 2.0f * engine->state.y / engine->height -1.f;
LOGI( "Trimming memory" );
_glContext->invalidate();
}
/**
* Process the next input event.
*/
static int32_t engine_handle_input(struct android_app* app, AInputEvent* event) {
struct engine* engine = (struct engine*)app->userData;
if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) {
engine->animating = 1;
int32_t engine::handleInput( android_app* app, AInputEvent* event )
{
engine* eng = (engine*)app->userData;
if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION)
{
GESTURE_STATE doubleTapState = eng->_doubletapDetector.detect(event);
GESTURE_STATE dragState = eng->_dragDetector.detect(event);
GESTURE_STATE pinchState = eng->_pinchDetector.detect(event);
int32_t iCount = AMotionEvent_getPointerCount(event);
int32_t iAction = AMotionEvent_getAction(event);
unsigned int flags = iAction & AMOTION_EVENT_ACTION_MASK;
float fX;
float fY;
float fX2;
float fY2;
switch( flags )
{
case AMOTION_EVENT_ACTION_DOWN:
engine->_vecPointers.push_back(AMotionEvent_getPointerId(event, 0));
//Double tap detector has a priority over other detectors
if( doubleTapState == GESTURE_STATE_ACTION )
{
//Detect double tap
eng->_tapCamera.reset(true);
}
else
{
//Handle drag state
if( dragState & GESTURE_STATE_START )
{
//Otherwise, start dragging
vec2 v;
eng->_dragDetector.getPointer( v );
eng->transformPosition( v );
eng->_tapCamera.beginDrag( v );
}
else if( dragState & GESTURE_STATE_MOVE )
{
vec2 v;
eng->_dragDetector.getPointer( v );
eng->transformPosition( v );
eng->_tapCamera.drag( v );
}
else if( dragState & GESTURE_STATE_END )
{
eng->_tapCamera.endDrag();
}
//Single touch
if( engine->_doubletapDetector.detect(event) )
{
//Detect double tap
engine->_tapCamera.reset(true);
}
else
{
//Otherwise, start dragging
updatePosition(engine, event, 0, fX, fY);
engine->_tapCamera.beginDrag( vec2( fX, fY ) );
}
break;
case AMOTION_EVENT_ACTION_POINTER_DOWN:
{
int32_t iIndex = (iAction & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
engine->_vecPointers.push_back(AMotionEvent_getPointerId(event, iIndex));
if( iCount == 2 )
{
//Start pinch
//Start new pinch
int32_t iIndex = findIndex( event, engine->_vecPointers[0] );
updatePosition(engine, event, iIndex, fX, fY);
iIndex = findIndex( event, engine->_vecPointers[1] );
updatePosition(engine, event, iIndex, fX2, fY2);
engine->_tapCamera.beginPinch( vec2( fX, fY ), vec2( fX2, fY2 ) );
}
}
break;
case AMOTION_EVENT_ACTION_UP:
//Update doubletap detector
engine->_doubletapDetector.detect(event);
engine->_vecPointers.pop_back();
engine->_tapCamera.endDrag();
break;
case AMOTION_EVENT_ACTION_POINTER_UP:
{
int32_t iIndex = (iAction & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
int32_t iReleasedPointerID = AMotionEvent_getPointerId(event, iIndex);
std::vector<int32_t>::iterator it = engine->_vecPointers.begin();
std::vector<int32_t>::iterator itEnd = engine->_vecPointers.end();
int32_t i = 0;
for(;it!=itEnd;++it, ++i)
{
if( *it == iReleasedPointerID )
{
engine->_vecPointers.erase(it);
break;
}
}
if( i <= 1 )
{
//Reset pinch or drag
if( iCount == 2 )
{
//Start new drag
int32_t iIndex = findIndex( event, engine->_vecPointers.front() );
updatePosition(engine, event, iIndex, fX, fY);
engine->_tapCamera.beginDrag( vec2( fX, fY ) );
}
else
{
//Start new pinch
int32_t iIndex = findIndex( event, engine->_vecPointers[0] );
updatePosition(engine, event, iIndex, fX, fY);
iIndex = findIndex( event, engine->_vecPointers[1] );
updatePosition(engine, event, iIndex, fX2, fY2);
engine->_tapCamera.beginPinch( vec2( fX, fY ), vec2( fX2, fY2 ) );
}
}
}
break;
case AMOTION_EVENT_ACTION_MOVE:
{
switch(iCount)
{
case 1:
{
//Single touch
int32_t iIndex = findIndex( event, engine->_vecPointers.front() );
updatePosition(engine, event, iIndex, fX, fY);
engine->_tapCamera.drag( vec2( fX, fY ) );
}
break;
default:
{
//Multi touch
int32_t iIndex = findIndex( event, engine->_vecPointers[0] );
updatePosition(engine, event, iIndex, fX, fY);
iIndex = findIndex( event, engine->_vecPointers[1] );
updatePosition(engine, event, iIndex, fX2, fY2);
engine->_tapCamera.pinch( vec2( fX, fY ), vec2( fX2, fY2 ) );
}
break;
}
break;
}
case AMOTION_EVENT_ACTION_CANCEL:
break;
}
return 1;
//Handle pinch state
if( pinchState & GESTURE_STATE_START )
{
//Start new pinch
vec2 v1;
vec2 v2;
eng->_pinchDetector.getPointers( v1, v2 );
eng->transformPosition( v1 );
eng->transformPosition( v2 );
eng->_tapCamera.beginPinch( v1, v2 );
}
else if( pinchState & GESTURE_STATE_MOVE )
{
//Multi touch
//Start new pinch
vec2 v1;
vec2 v2;
eng->_pinchDetector.getPointers( v1, v2 );
eng->transformPosition( v1 );
eng->transformPosition( v2 );
eng->_tapCamera.pinch( v1, v2 );
}
}
return 1;
}
return 0;
}
@@ -406,130 +277,206 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
/**
* Process the next main command.
*/
static void engine_handle_cmd(struct android_app* app, int32_t cmd) {
struct engine* engine = (struct engine*)app->userData;
void engine::handleCmd(struct android_app* app, int32_t cmd)
{
engine* eng = (engine*)app->userData;
switch (cmd) {
case APP_CMD_SAVE_STATE:
// The system has asked us to save our current state. Do so.
engine->app->savedState = malloc(sizeof(struct saved_state));
*((struct saved_state*)engine->app->savedState) = engine->state;
engine->app->savedStateSize = sizeof(struct saved_state);
break;
case APP_CMD_INIT_WINDOW:
// The window is being shown, get it ready.
if (engine->app->window != NULL) {
engine_init_display(engine);
engine_draw_frame(engine);
engine->animating = 1;
if (app->window != NULL) {
eng->initDisplay();
eng->drawFrame();
}
break;
case APP_CMD_TERM_WINDOW:
// The window is being hidden or closed, clean it up.
engine_term_display(engine);
eng->termDisplay();
eng->_bHasFocus = false;
break;
case APP_CMD_STOP:
break;
case APP_CMD_GAINED_FOCUS:
// When our app gains focus, we start monitoring the accelerometer.
if (engine->accelerometerSensor != NULL) {
ASensorEventQueue_enableSensor(engine->sensorEventQueue,
engine->accelerometerSensor);
// We'd like to get 60 events per second (in us).
ASensorEventQueue_setEventRate(engine->sensorEventQueue,
engine->accelerometerSensor, (1000L/60)*1000);
}
eng->resumeSensors();
//Start animation
eng->_bHasFocus = true;
break;
case APP_CMD_LOST_FOCUS:
// When our app loses focus, we stop monitoring the accelerometer.
// This is to avoid consuming battery while not being used.
if (engine->accelerometerSensor != NULL) {
ASensorEventQueue_disableSensor(engine->sensorEventQueue,
engine->accelerometerSensor);
}
eng->suspendSensors();
// Also stop animating.
engine->animating = 0;
engine_draw_frame(engine);
eng->_bHasFocus = false;
eng->drawFrame();
break;
case APP_CMD_LOW_MEMORY:
//Free up GL resources
eng->trimMemory();
break;
}
}
//-------------------------------------------------------------------------
//Sensor handlers
//-------------------------------------------------------------------------
void engine::initSensors()
{
_sensorManager = ASensorManager_getInstance();
_accelerometerSensor = ASensorManager_getDefaultSensor( _sensorManager,
ASENSOR_TYPE_ACCELEROMETER);
_sensorEventQueue = ASensorManager_createEventQueue( _sensorManager,
_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 (_accelerometerSensor != NULL)
{
ASensorEvent event;
while (ASensorEventQueue_getEvents(_sensorEventQueue,
&event, 1) > 0)
{
}
}
}
}
void engine::resumeSensors()
{
// When our app gains focus, we start monitoring the accelerometer.
if (_accelerometerSensor != NULL) {
ASensorEventQueue_enableSensor(_sensorEventQueue,
_accelerometerSensor);
// We'd like to get 60 events per second (in us).
ASensorEventQueue_setEventRate(_sensorEventQueue,
_accelerometerSensor, (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 (_accelerometerSensor != NULL) {
ASensorEventQueue_disableSensor(_sensorEventQueue,
_accelerometerSensor);
}
}
//-------------------------------------------------------------------------
//Misc
//-------------------------------------------------------------------------
void engine::setState(android_app* state)
{
_app = state;
_doubletapDetector.setConfiguration( _app->config );
_dragDetector.setConfiguration( _app->config );
_pinchDetector.setConfiguration( _app->config );
}
bool engine::isReady()
{
if( _bHasFocus )
return true;
return false;
}
void engine::transformPosition( vec2& vec )
{
vec = vec2( 2.0f, 2.0f ) * vec / vec2( _glContext->getScreenWidth(), _glContext->getScreenHeight() ) - 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(struct android_app* state) {
engine engine;
// Make sure glue isn't stripped.
void android_main(android_app* state)
{
app_dummy();
state->userData = &engine;
state->onAppCmd = engine_handle_cmd;
state->onInputEvent = engine_handle_input;
engine.app = state;
engine._doubletapDetector.setConfiguration(state->config);
g_engine.setState( state );
//Init helper functions
JNIHelper::init( state->activity );
state->userData = &g_engine;
state->onAppCmd = engine::handleCmd;
state->onInputEvent = engine::handleInput;
#ifdef USE_NDK_PROFILER
monstartup("libNativeActivity.so");
#endif
// Prepare to monitor accelerometer
engine.sensorManager = ASensorManager_getInstance();
engine.accelerometerSensor = ASensorManager_getDefaultSensor(engine.sensorManager,
ASENSOR_TYPE_ACCELEROMETER);
engine.sensorEventQueue = ASensorManager_createEventQueue(engine.sensorManager,
state->looper, LOOPER_ID_USER, NULL, NULL);
if (state->savedState != NULL) {
// We are starting with a previous saved state; restore from it.
engine.state = *(struct saved_state*)state->savedState;
}
g_engine.initSensors();
// loop waiting for stuff to do.
while (1) {
// Read all pending events.
int ident;
int id;
int events;
struct android_poll_source* source;
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 ((ident=ALooper_pollAll(engine.animating ? 0 : -1, NULL, &events,
(void**)&source)) >= 0) {
while ((id = ALooper_pollAll( g_engine.isReady() ? 0 : -1, NULL, &events,
(void**)&source) ) >= 0)
{
// Process this event.
if (source != NULL) {
if (source != NULL)
source->process(state, source);
}
// If a sensor has data, process it now.
if (ident == LOOPER_ID_USER) {
if (engine.accelerometerSensor != NULL) {
ASensorEvent event;
while (ASensorEventQueue_getEvents(engine.sensorEventQueue,
&event, 1) > 0) {
}
}
}
g_engine.processSensors( id );
// Check if we are exiting.
if (state->destroyRequested != 0) {
engine_term_display(&engine);
if (state->destroyRequested != 0)
{
g_engine.termDisplay();
return;
}
}
if (engine.animating) {
// Done with events; draw next animation frame.
engine.state.angle += .01f;
if (engine.state.angle > 1) {
engine.state.angle = 0;
}
if( g_engine.isReady() )
{
// Drawing is throttled to the screen update rate, so there
// is no need to do timing here.
engine_draw_frame(&engine);
g_engine.drawFrame();
}
}
}

13
ndk/platforms/android-17/samples/Teapot/jni/TeapotRenderer.cpp
View File

@@ -85,6 +85,15 @@ void TeapotRenderer::init()
delete[] p;
updateViewport();
_mModel = mat4::translation(0, 0, -15.f);
mat4 mat = mat4::rotationX(M_PI / 3);
_mModel = mat * _mModel;
}
void TeapotRenderer::updateViewport()
{
//Init Projection matrices
int32_t viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
@@ -95,10 +104,6 @@ void TeapotRenderer::init()
bool bRotate = false;
_mProjection = mat4::perspective(fAspect, 1.f,
CAM_NEAR, CAM_FAR);
_mModel = mat4::translation(0, 0, -15.f);
mat4 mat = mat4::rotationX(M_PI / 3);
_mModel = mat * _mModel;
}
void TeapotRenderer::unload()

7
ndk/platforms/android-17/samples/Teapot/jni/TeapotRenderer.h
View File

@@ -38,7 +38,10 @@
#include <android/native_window_jni.h>
#include <cpu-features.h>
#include "NDKSupport/NDKSupport.h"
#define CLASS_NAME "android/app/NativeActivity"
#define APPLICATION_CLASS_NAME "com/sample/teapot/TeapotApplication"
#include "NDKHelper.h"
#define BUFFER_OFFSET(i) ((char *)NULL + (i))
@@ -95,7 +98,7 @@ public:
void update(float dTime);
bool bind(tapCamera* camera);
void unload();
void updateViewport();
};
#endif

147
ndk/platforms/android-17/samples/Teapot/src/com/sample/helper/NDKHelper.java Normal file
View File

@@ -0,0 +1,147 @@
package com.sample.helper;
import java.io.File;
import java.io.FileInputStream;
import javax.microedition.khronos.opengles.GL10;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.opengl.GLUtils;
import android.util.Log;
public class NDKHelper {
private static Context context;
public static void setCotext( Context c )
{
Log.i("NDKHelper", "set context:" + c);
context = c;
}
//
//Load Bitmap
//Java helper is useful decoding PNG, TIFF etc rather than linking libPng etc separately
//
private int nextPOT(int i)
{
int pot = 1;
while( pot < i ) pot <<= 1;
return pot;
}
private Bitmap scaleBitmap(Bitmap bitmapToScale, float newWidth, float newHeight)
{
if(bitmapToScale == null)
return null;
//get the original width and height
int width = bitmapToScale.getWidth();
int height = bitmapToScale.getHeight();
// create a matrix for the manipulation
Matrix matrix = new Matrix();
// resize the bit map
matrix.postScale(newWidth / width, newHeight / height);
// recreate the new Bitmap and set it back
return Bitmap.createBitmap(bitmapToScale, 0, 0, bitmapToScale.getWidth(), bitmapToScale.getHeight(), matrix, true);
}
public void loadTexture(String path)
{
Bitmap bitmap = null;
try
{
String str = path;
if (!path.startsWith("/"))
{
str = "/" + path;
}
File file = new File(context.getExternalFilesDir(null), str);
if( file.canRead() )
{
bitmap = BitmapFactory.decodeStream(new FileInputStream(file));
}
else
{
bitmap = BitmapFactory.decodeStream(context.getResources().getAssets().open(path));
}
// Matrix matrix = new Matrix();
// // resize the bit map
// matrix.postScale(-1F, 1F);
//
// // recreate the new Bitmap and set it back
// bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
}
catch (Exception e) {
Log.w("NDKHelper", "Coundn't load a file:" + path);
}
if( bitmap != null )
{
GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);
}
return;
}
public Bitmap openBitmap(String path, boolean iScalePOT)
{
Bitmap bitmap = null;
try
{
bitmap = BitmapFactory.decodeStream(context.getResources().getAssets().open(path));
if( iScalePOT )
{
int originalWidth = getBitmapWidth(bitmap);
int originalHeight = getBitmapHeight(bitmap);
int width = nextPOT(originalWidth);
int height = nextPOT(originalHeight);
if( originalWidth != width || originalHeight != height )
{
//Scale it
bitmap = scaleBitmap( bitmap, width, height );
}
}
}
catch (Exception e) {
Log.w("NDKHelper", "Coundn't load a file:" + path);
}
return bitmap;
}
public int getBitmapWidth(Bitmap bmp) { return bmp.getWidth(); }
public int getBitmapHeight(Bitmap bmp) { return bmp.getHeight(); }
public void getBitmapPixels(Bitmap bmp, int[] pixels)
{
int w = bmp.getWidth();
int h = bmp.getHeight();
bmp.getPixels(pixels, 0, w, 0, 0, w, h);
}
public void closeBitmap(Bitmap bmp)
{
bmp.recycle();
}
public static String getNativeLibraryDirectory(Context appContext) {
ApplicationInfo ai = context.getApplicationInfo();
Log.w("NDKHelper", "ai.nativeLibraryDir:" + ai.nativeLibraryDir );
if ((ai.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0 ||
(ai.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
return ai.nativeLibraryDir;
}
return "/system/lib/";
}
}

85
ndk/platforms/android-17/samples/Teapot/src/com/sample/teapot/TeapotApplication.java
View File

@@ -15,9 +15,7 @@ import android.util.Log;
import android.widget.Toast;
public class TeapotApplication extends Application {
private static Context context;
public void onCreate(){
context=getApplicationContext();
Log.w("native-activity", "onCreate");
final PackageManager pm = getApplicationContext().getPackageManager();
@@ -30,87 +28,4 @@ public class TeapotApplication extends Application {
final String applicationName = (String) (ai != null ? pm.getApplicationLabel(ai) : "(unknown)");
Toast.makeText(this, applicationName, Toast.LENGTH_SHORT).show();
}
//Load Bitmap
private int nextPOT(int i)
{
int pot = 1;
while( pot < i ) pot <<= 1;
return pot;
}
private Bitmap scaleBitmap(Bitmap bitmapToScale, float newWidth, float newHeight)
{
if(bitmapToScale == null)
return null;
//get the original width and height
int width = bitmapToScale.getWidth();
int height = bitmapToScale.getHeight();
// create a matrix for the manipulation
Matrix matrix = new Matrix();
// resize the bit map
matrix.postScale(newWidth / width, newHeight / height);
// recreate the new Bitmap and set it back
return Bitmap.createBitmap(bitmapToScale, 0, 0, bitmapToScale.getWidth(), bitmapToScale.getHeight(), matrix, true);
}
public void loadTexture(String path)
{
Bitmap bitmap = null;
try
{
bitmap = BitmapFactory.decodeStream(context.getResources().getAssets().open(path));
}
catch (Exception e) {
Log.w("native-activity", "Coundn't load a file:" + path);
}
GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);
return;
}
public Bitmap openBitmap(String path, boolean iScalePOT)
{
Bitmap bitmap = null;
try
{
bitmap = BitmapFactory.decodeStream(context.getResources().getAssets().open(path));
if( iScalePOT )
{
int originalWidth = getBitmapWidth(bitmap);
int originalHeight = getBitmapHeight(bitmap);
int width = nextPOT(originalWidth);
int height = nextPOT(originalHeight);
if( originalWidth != width || originalHeight != height )
{
//Scale it
bitmap = scaleBitmap( bitmap, width, height );
}
}
}
catch (Exception e) {
Log.w("native-activity", "Coundn't load a file:" + path);
}
return bitmap;
}
public int getBitmapWidth(Bitmap bmp) { return bmp.getWidth(); }
public int getBitmapHeight(Bitmap bmp) { return bmp.getHeight(); }
public void getBitmapPixels(Bitmap bmp, int[] pixels)
{
int w = bmp.getWidth();
int h = bmp.getHeight();
bmp.getPixels(pixels, 0, w, 0, 0, w, h);
}
public void closeBitmap(Bitmap bmp)
{
bmp.recycle();
}
}

7
ndk/platforms/android-17/samples/Teapot/src/com/sample/teapot/TeapotNativeActivity.java
View File

@@ -22,9 +22,12 @@ public class TeapotNativeActivity extends NativeActivity {
//Hide toolbar
int SDK_INT = android.os.Build.VERSION.SDK_INT;
if(SDK_INT >= 11 && SDK_INT < 14) {
if(SDK_INT >= 11 && SDK_INT < 14)
{
getWindow().getDecorView().setSystemUiVisibility(View.STATUS_BAR_HIDDEN);
}else if(SDK_INT >= 14){
}
else if(SDK_INT >= 14)
{
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_LOW_PROFILE);
}

34
ndk/platforms/android-18/samples/MoreTeapots/AndroidManifest.xml Normal file
View File

@@ -0,0 +1,34 @@
<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="17" />
<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="NativeActivity" />
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

23
ndk/platforms/android-18/samples/MoreTeapots/assets/Shaders/ShaderPlain.fsh Normal file
View File

@@ -0,0 +1,23 @@
//
// ShaderPlain.fsh
//
uniform lowp vec3 vMaterialAmbient;
uniform lowp vec4 vMaterialSpecular;
varying lowp vec4 colorDiffuse;
uniform highp vec3 vLight0;
varying mediump vec3 position;
varying mediump vec3 normal;
void main()
{
mediump vec3 halfVector = normalize(-vLight0 + position);
mediump float NdotH = max(dot(normalize(normal), halfVector), 0.0);
mediump float fPower = vMaterialSpecular.w;
mediump float specular = pow(NdotH, fPower);
lowp vec4 colorSpecular = vec4( vMaterialSpecular.xyz * specular, 1 );
gl_FragColor = colorDiffuse + colorSpecular;
}

21
ndk/platforms/android-18/samples/MoreTeapots/assets/Shaders/ShaderPlainES3.fsh Normal file
View File

@@ -0,0 +1,21 @@
#version 300 es
precision mediump float;
uniform lowp vec4 vMaterialSpecular;
uniform highp vec3 vLight0;
in lowp vec4 colorDiffuse;
in vec3 position;
in vec3 normal;
out vec4 outColor;
void main()
{
mediump vec3 halfVector = normalize(-vLight0 + position);
mediump float NdotH = max(dot(normalize(normal), halfVector), 0.0);
mediump float fPower = vMaterialSpecular.w;
mediump float specular = pow(NdotH, fPower);
lowp vec4 colorSpecular = vec4( vMaterialSpecular.xyz * specular, 1 );
outColor = colorDiffuse + colorSpecular;
}

34
ndk/platforms/android-18/samples/MoreTeapots/assets/Shaders/VS_ShaderPlain.vsh Normal file
View File

@@ -0,0 +1,34 @@
//
// ShaderPlain.vsh
//
attribute highp vec3 myVertex;
attribute highp vec3 myNormal;
varying lowp vec4 colorDiffuse;
varying mediump vec3 position;
varying mediump vec3 normal;
uniform highp mat4 uMVMatrix;
uniform highp mat4 uPMatrix;
uniform highp vec3 vLight0;
uniform lowp vec4 vMaterialDiffuse;
uniform lowp vec3 vMaterialAmbient;
uniform lowp vec4 vMaterialSpecular;
void main(void)
{
highp vec4 p = vec4(myVertex,1);
gl_Position = uPMatrix * p;
highp vec3 worldNormal = vec3(mat3(uMVMatrix[0].xyz, uMVMatrix[1].xyz, uMVMatrix[2].xyz) * myNormal);
highp vec3 ecPosition = p.xyz;
colorDiffuse = dot( worldNormal, normalize(-vLight0+ecPosition) ) * vMaterialDiffuse + vec4( vMaterialAmbient, 1 );
normal = worldNormal;
position = ecPosition;
}

42
ndk/platforms/android-18/samples/MoreTeapots/assets/Shaders/VS_ShaderPlainES3.vsh Normal file
View File

@@ -0,0 +1,42 @@
#version 300 es
precision mediump float;
//
//Shader with phoneshading + geometry instancing support
//Parameters with %PARAM_NAME% will be replaced to actual parameter at compile time
//
const int NUM_OBJECTS = %NUM_TEAPOT%;
layout(location=%LOCATION_VERTEX%) in highp vec3 myVertex;
layout(location=%LOCATION_NORMAL%) in highp vec3 myNormal;
layout(std140) uniform ParamBlock {
mat4 uPMatrix[NUM_OBJECTS];
mat4 uMVMatrix[NUM_OBJECTS];
vec3 vMaterialDiffuse[NUM_OBJECTS];
};
uniform highp vec3 vLight0;
uniform lowp vec3 vMaterialAmbient;
uniform lowp vec4 vMaterialSpecular;
out lowp vec4 colorDiffuse;
out mediump vec3 position;
out mediump vec3 normal;
void main(void)
{
highp vec4 p = vec4(myVertex,1);
gl_Position = uPMatrix[gl_InstanceID%ARB%] * p;
highp vec3 worldNormal = vec3(mat3(uMVMatrix[gl_InstanceID%ARB%][0].xyz,
uMVMatrix[gl_InstanceID%ARB%][1].xyz,
uMVMatrix[gl_InstanceID%ARB%][2].xyz) * myNormal);
highp vec3 ecPosition = p.xyz;
colorDiffuse = dot( worldNormal, normalize(-vLight0+ecPosition) ) * vec4(vMaterialDiffuse[gl_InstanceID%ARB%], 1.f) + vec4( vMaterialAmbient, 1 );
normal = worldNormal;
position = ecPosition;
}

19
ndk/platforms/android-18/samples/MoreTeapots/jni/Android.mk Normal file
View File

@@ -0,0 +1,19 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := NativeActivity
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 helper
include $(BUILD_SHARED_LIBRARY)
$(call import-module,android/helper)
$(call import-module,android/native_app_glue)
$(call import-module,android/cpufeatures)

4
ndk/platforms/android-18/samples/MoreTeapots/jni/Application.mk Normal file
View File

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

484
ndk/platforms/android-18/samples/MoreTeapots/jni/MoreTeapotsNativeActivity.cpp Normal file
View File

@@ -0,0 +1,484 @@
/*
* 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"
const int32_t NUM_TEAPOTS_X = 8;
const int32_t NUM_TEAPOTS_Y = 8;
const int32_t NUM_TEAPOTS_Z = 6;
//-------------------------------------------------------------------------
//Shared state for our app.
//-------------------------------------------------------------------------
struct android_app;
class engine {
MoreTeapotsRenderer _renderer;
GLContext* _glContext;
bool _bInitializedResources;
bool _bHasFocus;
DoubletapDetector _doubletapDetector;
PinchDetector _pinchDetector;
DragDetector _dragDetector;
perfMonitor _monitor;
tapCamera _tapCamera;
android_app* _app;
ASensorManager* _sensorManager;
const ASensor* _accelerometerSensor;
ASensorEventQueue* _sensorEventQueue;
void updateFPS(float fFPS);
void showUI();
void transformPosition( 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() :
_bInitializedResources( false ),
_bHasFocus( false ),
_app( NULL ),
_sensorManager( NULL ),
_accelerometerSensor( NULL ),
_sensorEventQueue( NULL )
{
_glContext = GLContext::getInstance();
}
//-------------------------------------------------------------------------
//Dtor
//-------------------------------------------------------------------------
engine::~engine()
{
}
/**
* Load resources
*/
void engine::loadResources()
{
_renderer.init(NUM_TEAPOTS_X, NUM_TEAPOTS_Y, NUM_TEAPOTS_Z);
_renderer.bind(&_tapCamera);
}
/**
* Unload resources
*/
void engine::unloadResources()
{
_renderer.unload();
}
/**
* Initialize an EGL context for the current display.
*/
int engine::initDisplay()
{
if( !_bInitializedResources )
{
_glContext->init( _app->window );
loadResources();
_bInitializedResources = true;
}
else
{
// initialize OpenGL ES and EGL
if( EGL_SUCCESS != _glContext->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,
_glContext->getScreenWidth(),
_glContext->getScreenHeight() );
_renderer.updateViewport();
_tapCamera.setFlip(1.f, -1.f, -1.f);
_tapCamera.setPinchTransformFactor(10.f, 10.f, 8.f);
return 0;
}
/**
* Just the current frame in the display.
*/
void engine::drawFrame()
{
float fFPS;
if( _monitor.update(fFPS) )
{
updateFPS( fFPS );
}
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 != _glContext->swap() )
{
unloadResources();
loadResources();
}
}
/**
* Tear down the EGL context currently associated with the display.
*/
void engine::termDisplay()
{
_glContext->suspend();
}
void engine::trimMemory()
{
LOGI( "Trimming memory" );
_glContext->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)
{
GESTURE_STATE doubleTapState = eng->_doubletapDetector.detect(event);
GESTURE_STATE dragState = eng->_dragDetector.detect(event);
GESTURE_STATE pinchState = eng->_pinchDetector.detect(event);
//Double tap detector has a priority over other detectors
if( doubleTapState == GESTURE_STATE_ACTION )
{
//Detect double tap
eng->_tapCamera.reset(true);
}
else
{
//Handle drag state
if( dragState & GESTURE_STATE_START )
{
//Otherwise, start dragging
vec2 v;
eng->_dragDetector.getPointer( v );
eng->transformPosition( v );
eng->_tapCamera.beginDrag( v );
}
else if( dragState & GESTURE_STATE_MOVE )
{
vec2 v;
eng->_dragDetector.getPointer( v );
eng->transformPosition( v );
eng->_tapCamera.drag( v );
}
else if( dragState & GESTURE_STATE_END )
{
eng->_tapCamera.endDrag();
}
//Handle pinch state
if( pinchState & GESTURE_STATE_START )
{
//Start new pinch
vec2 v1;
vec2 v2;
eng->_pinchDetector.getPointers( v1, v2 );
eng->transformPosition( v1 );
eng->transformPosition( v2 );
eng->_tapCamera.beginPinch( v1, v2 );
}
else if( pinchState & GESTURE_STATE_MOVE )
{
//Multi touch
//Start new pinch
vec2 v1;
vec2 v2;
eng->_pinchDetector.getPointers( v1, v2 );
eng->transformPosition( v1 );
eng->transformPosition( v2 );
eng->_tapCamera.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->_bHasFocus = false;
break;
case APP_CMD_STOP:
break;
case APP_CMD_GAINED_FOCUS:
eng->resumeSensors();
//Start animation
eng->_bHasFocus = true;
break;
case APP_CMD_LOST_FOCUS:
eng->suspendSensors();
// Also stop animating.
eng->_bHasFocus = false;
eng->drawFrame();
break;
case APP_CMD_LOW_MEMORY:
//Free up GL resources
eng->trimMemory();
break;
}
}
//-------------------------------------------------------------------------
//Sensor handlers
//-------------------------------------------------------------------------
void engine::initSensors()
{
_sensorManager = ASensorManager_getInstance();
_accelerometerSensor = ASensorManager_getDefaultSensor( _sensorManager,
ASENSOR_TYPE_ACCELEROMETER);
_sensorEventQueue = ASensorManager_createEventQueue( _sensorManager,
_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 (_accelerometerSensor != NULL)
{
ASensorEvent event;
while (ASensorEventQueue_getEvents(_sensorEventQueue,
&event, 1) > 0)
{
}
}
}
}
void engine::resumeSensors()
{
// When our app gains focus, we start monitoring the accelerometer.
if (_accelerometerSensor != NULL) {
ASensorEventQueue_enableSensor(_sensorEventQueue,
_accelerometerSensor);
// We'd like to get 60 events per second (in us).
ASensorEventQueue_setEventRate(_sensorEventQueue,
_accelerometerSensor, (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 (_accelerometerSensor != NULL) {
ASensorEventQueue_disableSensor(_sensorEventQueue,
_accelerometerSensor);
}
}
//-------------------------------------------------------------------------
//Misc
//-------------------------------------------------------------------------
void engine::setState(android_app* state)
{
_app = state;
_doubletapDetector.setConfiguration( _app->config );
_dragDetector.setConfiguration( _app->config );
_pinchDetector.setConfiguration( _app->config );
}
bool engine::isReady()
{
if( _bHasFocus )
return true;
return false;
}
void engine::transformPosition( vec2& vec )
{
vec = vec2( 2.0f, 2.0f ) * vec / vec2( _glContext->getScreenWidth(), _glContext->getScreenHeight() ) - 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
JNIHelper::init( state->activity );
state->userData = &g_engine;
state->onAppCmd = engine::handleCmd;
state->onInputEvent = engine::handleInput;
#ifdef USE_NDK_PROFILER
monstartup("libNativeActivity.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();
}
}
}

556
ndk/platforms/android-18/samples/MoreTeapots/jni/MoreTeapotsRenderer.cpp Normal file
View File

@@ -0,0 +1,556 @@
/*
* 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() : _bGeometryInstancingSupport( false )
{
}
//--------------------------------------------------------------------------------
// Dtor
//--------------------------------------------------------------------------------
MoreTeapotsRenderer::~MoreTeapotsRenderer() {
unload();
}
//--------------------------------------------------------------------------------
// Init
//--------------------------------------------------------------------------------
void MoreTeapotsRenderer::init( const int32_t numX, const int32_t numY, const int32_t numZ )
{
if( GLContext::getInstance()->getGLVersion() >= 3.0 )
{
_bGeometryInstancingSupport = true;
}
else if( GLContext::getInstance()->checkExtension("GL_NV_draw_instanced")
&& 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
_iNumIndices = 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
_iNumVertices = sizeof(teapotPositions) / sizeof(teapotPositions[0]) / 3;
int32_t iStride = sizeof(TEAPOT_VERTEX);
int32_t iIndex = 0;
TEAPOT_VERTEX* p = new TEAPOT_VERTEX[_iNumVertices];
for( int32_t i = 0; i < _iNumVertices; ++i )
{
p[i].fPos[0] = teapotPositions[iIndex];
p[i].fPos[1] = teapotPositions[iIndex+1];
p[i].fPos[2] = teapotPositions[iIndex+2];
p[i].fNormal[0] = teapotNormals[iIndex];
p[i].fNormal[1] = teapotNormals[iIndex+1];
p[i].fNormal[2] = teapotNormals[iIndex+2];
iIndex += 3;
}
glGenBuffers(1, &_vbo);
glBindBuffer(GL_ARRAY_BUFFER, _vbo);
glBufferData(GL_ARRAY_BUFFER, iStride * _iNumVertices,
p, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
delete[] p;
//Init Projection matrices
_iX = numX;
_iY = numY;
_iZ = numZ;
_mModels.reserve( _iX * _iY * _iZ );
updateViewport();
float fTotalWidth = 500.f;
float fGapX = fTotalWidth / (_iX - 1);
float fGapY = fTotalWidth / (_iY - 1);
float fGapZ = fTotalWidth / (_iZ - 1);
float fOffsetX = -fTotalWidth/ 2.f;
float fOffsetY = -fTotalWidth/ 2.f;
float fOffsetZ = -fTotalWidth/ 2.f;
for( int32_t iX = 0; iX < _iX; ++iX )
for( int32_t iY = 0; iY < _iY; ++iY )
for( int32_t iZ = 0; iZ < _iZ; ++iZ )
{
_mModels.push_back( mat4::translation( iX * fGapX + fOffsetX,
iY * fGapY + fOffsetY,
iZ * fGapZ + fOffsetZ) );
_mColors.push_back(
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;
_mVecRotation.push_back(
vec2( fX * 0.05f, fY * 0.05f ) );
_mCurrentRotation.push_back(
vec2( fX * M_PI, fY * M_PI ) );
}
if( _bGeometryInstancingSupport )
{
//
//Create parameter dictionary for shader patch
std::map< std::string, std::string> param;
param[ std::string( "%NUM_TEAPOT%" ) ] = toString( _iX * _iY * _iZ );
param[ std::string( "%LOCATION_VERTEX%" ) ] = toString( ATTRIB_VERTEX );
param[ std::string( "%LOCATION_NORMAL%" ) ] = toString( ATTRIB_NORMAL );
if( _bARBSupport )
param[ std::string( "%ARB%" ) ] = std::string( "ARB" );
else
param[ std::string( "%ARB%" ) ] = std::string( "" );
//Load shader
bool b = loadShadersES3( &_shaderParam, "Shaders/VS_ShaderPlainES3.vsh", "Shaders/ShaderPlainES3.fsh", param );
if( b )
{
//
//Create uniform buffer
//
GLuint bindingPoint = 1;
GLuint blockIndex;
blockIndex = glGetUniformBlockIndex( _shaderParam._program, "ParamBlock" );
glUniformBlockBinding( _shaderParam._program, blockIndex, bindingPoint );
//Retrieve array stride value
int32_t iNumIndices;
glGetActiveUniformBlockiv( _shaderParam._program, blockIndex,
GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &iNumIndices );
GLint i[iNumIndices];
GLint stride[iNumIndices];
glGetActiveUniformBlockiv( _shaderParam._program, blockIndex,
GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, i );
glGetActiveUniformsiv( _shaderParam._program, iNumIndices, (GLuint*)i, GL_UNIFORM_ARRAY_STRIDE, stride );
_uboMatrixStride = stride[ 0 ] / sizeof(float);
_uboVectorStride = 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 = _iX * _iY * _iZ *
(_uboMatrixStride+_uboMatrixStride+_uboVectorStride); //mat4 + mat4 + vec3 + 1 stride
float* pBuffer = new float[iSize];
float* pColor = pBuffer + _iX * _iY * _iZ * _uboMatrixStride*2;
for( int32_t i = 0; i < _iX * _iY * _iZ; ++i )
{
memcpy(pColor, &_mColors[ i ], 3 * sizeof(float));
pColor += _uboVectorStride; //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.
_bGeometryInstancingSupport = false;
//Load shader for GLES2.0
loadShaders( &_shaderParam, "Shaders/VS_ShaderPlain.vsh", "Shaders/ShaderPlain.fsh" );
}
}
else
{
//Load shader for GLES2.0
loadShaders( &_shaderParam, "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;
_mProjection = 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 (_shaderParam._program )
{
glDeleteProgram(_shaderParam._program);
_shaderParam._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;
_mView = mat4::lookAt(vec3(CAM_X, CAM_Y, CAM_Z),
vec3(0.f, 0.f, 0.f), vec3(0.f, 1.f, 0.f));
if( _camera )
{
_camera->update();
_mView = _camera->getTransformMatrix() * _mView * _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(_shaderParam._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(_shaderParam._uiMaterialSpecular,
material.specular_color[0],
material.specular_color[1],
material.specular_color[2],
material.specular_color[3]);
glUniform3f(_shaderParam._uiMaterialAmbient,
material.ambient_color[0],
material.ambient_color[1],
material.ambient_color[2]);
glUniform3f(_shaderParam._uiLight0, 100.f, -200.f, -600.f);
if( _bGeometryInstancingSupport )
{
//
//Geometry instancing, new feature in GLES3.0
//
//Update UBO
glBindBuffer(GL_UNIFORM_BUFFER, _ubo);
float* p = (float*)glMapBufferRange(GL_UNIFORM_BUFFER,
0, _iX * _iY * _iZ * (_uboMatrixStride * 2) * sizeof(float),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT);
float* pMVPMat = p;
float* pMVMat = p + _iX * _iY * _iZ * _uboMatrixStride;
for( int32_t i = 0; i < _iX * _iY * _iZ; ++i )
{
//Rotation
float fX, fY;
_mCurrentRotation[ i ] += _mVecRotation[ i ];
_mCurrentRotation[ i ].value( fX, fY );
mat4 mRotation = mat4::rotationX( fX ) * mat4::rotationY( fY );
// Feed Projection and Model View matrices to the shaders
mat4 mV = _mView * _mModels[ i ] * mRotation;
mat4 mVP = _mProjection * mV;
memcpy(pMVPMat, mVP.ptr(), sizeof(mV) );
pMVPMat += _uboMatrixStride;
memcpy(pMVMat, mV.ptr(), sizeof(mV) );
pMVMat += _uboMatrixStride;
}
glUnmapBuffer(GL_UNIFORM_BUFFER);
//Instanced rendering
glDrawElementsInstanced(GL_TRIANGLES, _iNumIndices, GL_UNSIGNED_SHORT,
BUFFER_OFFSET(0), _iX * _iY * _iZ);
}
else
{
//Regular rendering pass
for( int32_t i = 0; i < _iX * _iY * _iZ; ++i )
{
//Set diffuse
float fX, fY, fZ;
_mColors[ i ].value( fX, fY, fZ );
glUniform4f(_shaderParam._uiMaterialDiffuse, fX, fY, fZ,
1.f);
//Rotation
_mCurrentRotation[ i ] += _mVecRotation[ i ];
_mCurrentRotation[ i ].value( fX, fY );
mat4 mRotation = mat4::rotationX( fX ) * mat4::rotationY( fY );
// Feed Projection and Model View matrices to the shaders
mat4 mV = _mView * _mModels[ i ] * mRotation;
mat4 mVP = _mProjection * mV;
glUniformMatrix4fv(_shaderParam._uiMatrixP, 1, GL_FALSE,
mVP.ptr());
glUniformMatrix4fv(_shaderParam._uiMatrixView, 1, GL_FALSE,
mV.ptr());
glDrawElements(GL_TRIANGLES, _iNumIndices, 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 (!shader::compileShader(&vertShader, GL_VERTEX_SHADER, strVsh)) {
LOGI("Failed to compile vertex shader");
glDeleteProgram(program);
return false;
}
// Create and compile fragment shader
if (!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 (!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->_uiMatrixP = glGetUniformLocation(program, "uPMatrix");
params->_uiMatrixView = glGetUniformLocation(program, "uMVMatrix");
params->_uiLight0 = glGetUniformLocation(program, "vLight0");
params->_uiMaterialDiffuse = glGetUniformLocation(program,
"vMaterialDiffuse");
params->_uiMaterialAmbient = glGetUniformLocation(program,
"vMaterialAmbient");
params->_uiMaterialSpecular = 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 (!shader::compileShader(&vertShader, GL_VERTEX_SHADER, strVsh, shaderParams)) {
LOGI("Failed to compile vertex shader");
glDeleteProgram(program);
return false;
}
// Create and compile fragment shader
if (!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 (!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->_uiLight0 = glGetUniformLocation(program, "vLight0");
params->_uiMaterialAmbient = glGetUniformLocation(program,
"vMaterialAmbient");
params->_uiMaterialSpecular = 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(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 );
}

121
ndk/platforms/android-18/samples/MoreTeapots/jni/MoreTeapotsRenderer.h Normal file
View File

@@ -0,0 +1,121 @@
/*
* 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 fPos[3];
float fNormal[3];
};
enum SHADER_ATTRIBUTES {
ATTRIB_VERTEX, ATTRIB_NORMAL, ATTRIB_COLOR, ATTRIB_UV
};
struct SHADER_PARAMS
{
GLuint _program;
GLuint _uiLight0;
GLuint _uiMaterialDiffuse;
GLuint _uiMaterialAmbient;
GLuint _uiMaterialSpecular;
GLuint _uiMatrixP;
GLuint _uiMatrixView;
};
struct TEAPOT_MATERIALS
{
float specular_color[ 4 ];
float ambient_color[ 3 ];
};
class MoreTeapotsRenderer
{
int32_t _iNumIndices;
int32_t _iNumVertices;
GLuint _ibo;
GLuint _vbo;
GLuint _ubo;
SHADER_PARAMS _shaderParam;
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 );
mat4 _mProjection;
mat4 _mView;
std::vector<mat4> _mModels;
std::vector<vec3> _mColors;
std::vector<vec2> _mVecRotation;
std::vector<vec2> _mCurrentRotation;
tapCamera* _camera;
int32_t _iX;
int32_t _iY;
int32_t _iZ;
int32_t _uboMatrixStride;
int32_t _uboVectorStride;
bool _bGeometryInstancingSupport;
bool _bARBSupport;
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(tapCamera* camera);
void unload();
void updateViewport();
};
#endif

2057
ndk/platforms/android-18/samples/MoreTeapots/jni/teapot.inl Normal file
View File

File diff suppressed because it is too large Load Diff

3
ndk/platforms/android-18/samples/MoreTeapots/lint.xml Normal file
View File

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

14
ndk/platforms/android-18/samples/MoreTeapots/project.properties Normal file
View File

@@ -0,0 +1,14 @@
# 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:17

BIN
ndk/platforms/android-18/samples/MoreTeapots/res/drawable-hdpi/ic_launcher.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.0 KiB

BIN
ndk/platforms/android-18/samples/MoreTeapots/res/drawable-ldpi/ic_launcher.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.5 KiB

BIN
ndk/platforms/android-18/samples/MoreTeapots/res/drawable-mdpi/ic_launcher.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.0 KiB

BIN
ndk/platforms/android-18/samples/MoreTeapots/res/drawable-xhdpi/ic_launcher.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 13 KiB

17
ndk/platforms/android-18/samples/MoreTeapots/res/layout/widgets.xml Normal file
View File

@@ -0,0 +1,17 @@
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="top"
android:orientation="vertical" >
<TextView
android:id="@+id/textViewFPS"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:gravity="right"
android:text="0.0 FPS"
android:textAppearance="?android:attr/textAppearanceMedium"
android:textColor="@android:color/white" />
</LinearLayout>

11
ndk/platforms/android-18/samples/MoreTeapots/res/values-v11/styles.xml Normal file
View File

@@ -0,0 +1,11 @@
<resources>
<!--
Base application theme for API 11+. This theme completely replaces
AppBaseTheme from res/values/styles.xml on API 11+ devices.
-->
<style name="AppBaseTheme" parent="android:Theme.Holo.Light">
<!-- API 11 theme customizations can go here. -->
</style>
</resources>

12
ndk/platforms/android-18/samples/MoreTeapots/res/values-v14/styles.xml Normal file
View File

@@ -0,0 +1,12 @@
<resources>
<!--
Base application theme for API 14+. This theme completely replaces
AppBaseTheme from BOTH res/values/styles.xml and
res/values-v11/styles.xml on API 14+ devices.
-->
<style name="AppBaseTheme" parent="android:Theme.Holo.Light.DarkActionBar">
<!-- API 14 theme customizations can go here. -->
</style>
</resources>

5
ndk/platforms/android-18/samples/MoreTeapots/res/values/strings.xml Normal file
View File

@@ -0,0 +1,5 @@
<resources>
<string name="app_name">More Teapots</string>
</resources>

20
ndk/platforms/android-18/samples/MoreTeapots/res/values/styles.xml Normal file
View File

@@ -0,0 +1,20 @@
<resources>
<!--
Base application theme, dependent on API level. This theme is replaced
by AppBaseTheme from res/values-vXX/styles.xml on newer devices.
-->
<style name="AppBaseTheme" parent="android:Theme.Light">
<!--
Theme customizations available in newer API levels can go in
res/values-vXX/styles.xml, while customizations related to
backward-compatibility can go here.
-->
</style>
<!-- Application theme. -->
<style name="AppTheme" parent="AppBaseTheme">
<!-- All customizations that are NOT specific to a particular API-level can go here. -->
</style>
</resources>

147
ndk/platforms/android-18/samples/MoreTeapots/src/com/sample/helper/NDKHelper.java Normal file
View File

@@ -0,0 +1,147 @@
package com.sample.helper;
import java.io.File;
import java.io.FileInputStream;
import javax.microedition.khronos.opengles.GL10;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.opengl.GLUtils;
import android.util.Log;
public class NDKHelper {
private static Context context;
public static void setCotext( Context c )
{
Log.i("NDKHelper", "set context:" + c);
context = c;
}
//
//Load Bitmap
//Java helper is useful decoding PNG, TIFF etc rather than linking libPng etc separately
//
private int nextPOT(int i)
{
int pot = 1;
while( pot < i ) pot <<= 1;
return pot;
}
private Bitmap scaleBitmap(Bitmap bitmapToScale, float newWidth, float newHeight)
{
if(bitmapToScale == null)
return null;
//get the original width and height
int width = bitmapToScale.getWidth();
int height = bitmapToScale.getHeight();
// create a matrix for the manipulation
Matrix matrix = new Matrix();
// resize the bit map
matrix.postScale(newWidth / width, newHeight / height);
// recreate the new Bitmap and set it back
return Bitmap.createBitmap(bitmapToScale, 0, 0, bitmapToScale.getWidth(), bitmapToScale.getHeight(), matrix, true);
}
public void loadTexture(String path)
{
Bitmap bitmap = null;
try
{
String str = path;
if (!path.startsWith("/"))
{
str = "/" + path;
}
File file = new File(context.getExternalFilesDir(null), str);
if( file.canRead() )
{
bitmap = BitmapFactory.decodeStream(new FileInputStream(file));
}
else
{
bitmap = BitmapFactory.decodeStream(context.getResources().getAssets().open(path));
}
// Matrix matrix = new Matrix();
// // resize the bit map
// matrix.postScale(-1F, 1F);
//
// // recreate the new Bitmap and set it back
// bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
}
catch (Exception e) {
Log.w("NDKHelper", "Coundn't load a file:" + path);
}
if( bitmap != null )
{
GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);
}
return;
}
public Bitmap openBitmap(String path, boolean iScalePOT)
{
Bitmap bitmap = null;
try
{
bitmap = BitmapFactory.decodeStream(context.getResources().getAssets().open(path));
if( iScalePOT )
{
int originalWidth = getBitmapWidth(bitmap);
int originalHeight = getBitmapHeight(bitmap);
int width = nextPOT(originalWidth);
int height = nextPOT(originalHeight);
if( originalWidth != width || originalHeight != height )
{
//Scale it
bitmap = scaleBitmap( bitmap, width, height );
}
}
}
catch (Exception e) {
Log.w("NDKHelper", "Coundn't load a file:" + path);
}
return bitmap;
}
public int getBitmapWidth(Bitmap bmp) { return bmp.getWidth(); }
public int getBitmapHeight(Bitmap bmp) { return bmp.getHeight(); }
public void getBitmapPixels(Bitmap bmp, int[] pixels)
{
int w = bmp.getWidth();
int h = bmp.getHeight();
bmp.getPixels(pixels, 0, w, 0, 0, w, h);
}
public void closeBitmap(Bitmap bmp)
{
bmp.recycle();
}
public static String getNativeLibraryDirectory(Context appContext) {
ApplicationInfo ai = context.getApplicationInfo();
Log.w("NDKHelper", "ai.nativeLibraryDir:" + ai.nativeLibraryDir );
if ((ai.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0 ||
(ai.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
return ai.nativeLibraryDir;
}
return "/system/lib/";
}
}

37
ndk/platforms/android-18/samples/MoreTeapots/src/com/sample/moreteapots/MoreTeapotsApplication.java Normal file
View File

@@ -0,0 +1,37 @@
package com.sample.moreteapots;
import javax.microedition.khronos.opengles.GL10;
import com.sample.helper.NDKHelper;
import android.app.Application;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.opengl.GLUtils;
import android.util.Log;
import android.widget.Toast;
public class MoreTeapotsApplication extends Application {
private static Context context;
public void onCreate(){
context=getApplicationContext();
NDKHelper.setCotext(context);
Log.w("native-activity", "onCreate");
final PackageManager pm = getApplicationContext().getPackageManager();
ApplicationInfo ai;
try {
ai = pm.getApplicationInfo( this.getPackageName(), 0);
} catch (final NameNotFoundException e) {
ai = null;
}
final String applicationName = (String) (ai != null ? pm.getApplicationLabel(ai) : "(unknown)");
Toast.makeText(this, applicationName, Toast.LENGTH_SHORT).show();
}
}

97
ndk/platforms/android-18/samples/MoreTeapots/src/com/sample/moreteapots/MoreTeapotsNativeActivity.java Normal file
View File

@@ -0,0 +1,97 @@
package com.sample.moreteapots;
import android.app.NativeActivity;
import android.os.Bundle;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup.MarginLayoutParams;
import android.view.WindowManager.LayoutParams;
import android.widget.LinearLayout;
import android.widget.PopupWindow;
import android.widget.TextView;
public class MoreTeapotsNativeActivity extends NativeActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
protected void onResume() {
super.onResume();
//Hide toolbar
int SDK_INT = android.os.Build.VERSION.SDK_INT;
if(SDK_INT >= 11 && SDK_INT < 14) {
getWindow().getDecorView().setSystemUiVisibility(View.STATUS_BAR_HIDDEN);
}else if(SDK_INT >= 14){
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_LOW_PROFILE);
}
}
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
MoreTeapotsNativeActivity _activity;
PopupWindow _popupWindow;
TextView _label;
public void showUI()
{
if( _popupWindow != null )
return;
_activity = this;
this.runOnUiThread(new Runnable() {
@Override
public void run() {
LayoutInflater layoutInflater
= (LayoutInflater)getBaseContext()
.getSystemService(LAYOUT_INFLATER_SERVICE);
View popupView = layoutInflater.inflate(R.layout.widgets, null);
_popupWindow = new PopupWindow(
popupView,
LayoutParams.WRAP_CONTENT,
LayoutParams.WRAP_CONTENT);
LinearLayout mainLayout = new LinearLayout(_activity);
MarginLayoutParams params = new MarginLayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
params.setMargins(0, 0, 0, 0);
_activity.setContentView(mainLayout, params);
// Show our UI over NativeActivity window
_popupWindow.showAtLocation(mainLayout, Gravity.TOP | Gravity.LEFT, 10, 10);
_popupWindow.update();
_label = (TextView)popupView.findViewById(R.id.textViewFPS);
}});
}
public void updateFPS(final float fFPS)
{
if( _label == null )
return;
_activity = this;
this.runOnUiThread(new Runnable() {
@Override
public void run() {
_label.setText(String.format("%2.2f FPS", fFPS));
}});
}
}

16
ndk/sources/android/helper/Android.mk Normal file
View File

@@ -0,0 +1,16 @@
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE:= helper
LOCAL_SRC_FILES:= JNIHelper.cpp interpolator.cpp tapCamera.cpp gestureDetector.cpp perfMonitor.cpp vecmath.cpp GLContext.cpp shader.cpp gl3stub.c
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
LOCAL_EXPORT_LDLIBS := -llog -landroid -lEGL -lGLESv2
LOCAL_STATIC_LIBRARIES := cpufeatures android_native_app_glue
include $(BUILD_STATIC_LIBRARY)
#$(call import-module,android/native_app_glue)
#$(call import-module,android/cpufeatures)

302
ndk/sources/android/helper/GLContext.cpp Normal file
View File

@@ -0,0 +1,302 @@
/*
* 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"
//--------------------------------------------------------------------------------
// eGLContext
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
// Ctor
//--------------------------------------------------------------------------------
GLContext::GLContext() : _display(EGL_NO_DISPLAY),
_surface(EGL_NO_SURFACE),
_context(EGL_NO_CONTEXT),
_iWidth( 0 ),
_iHeight( 0 ),
_bES3Support( false ),
_bEGLContextInitialized( false ),
_bGLESInitialized( false )
{
}
void GLContext::initGLES()
{
if( _bGLESInitialized )
return;
//
//Initialize OpenGL ES 3 if available
//
const char* versionStr = (const char*)glGetString(GL_VERSION);
if (strstr(versionStr, "OpenGL ES 3.")
&& gl3stubInit())
{
_bES3Support = true;
_fGLVersion = 3.0f;
}
else
{
_fGLVersion = 2.0f;
}
_bGLESInitialized = true;
}
//--------------------------------------------------------------------------------
// Dtor
//--------------------------------------------------------------------------------
GLContext::~GLContext()
{
terminate();
}
bool GLContext::init( ANativeWindow* window )
{
if( _bEGLContextInitialized )
return true;
//
//Initialize EGL
//
_window = window;
initEGLSurface();
initEGLContext();
initGLES();
_bEGLContextInitialized = 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
};
_iColorSize = 8;
_iDepthSize = 24;
EGLint numConfigs;
eglChooseConfig( _display, attribs, &_config, 1, &numConfigs );
if( !numConfigs )
{
//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, &numConfigs );
_iDepthSize = 16;
}
if ( !numConfigs )
{
LOGW("Unable to retrieve EGL config");
return false;
}
_surface = eglCreateWindowSurface( _display, _config, _window, NULL );
eglQuerySurface(_display, _surface, EGL_WIDTH, &_iWidth);
eglQuerySurface(_display, _surface, EGL_HEIGHT, &_iHeight);
/* EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is
* guaranteed to be accepted by ANativeWindow_setBuffersGeometry().
* As soon as we picked a EGLConfig, we can safely reconfigure the
* ANativeWindow buffers to match, using EGL_NATIVE_VISUAL_ID. */
EGLint format;
eglGetConfigAttrib(_display, _config, EGL_NATIVE_VISUAL_ID, &format);
ANativeWindow_setBuffersGeometry( _window, 0, 0, format);
return true;
}
bool GLContext::initEGLContext()
{
const EGLint contextAttribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2, //Request opengl ES2.0
EGL_NONE
};
_context = eglCreateContext( _display, _config, NULL, contextAttribs );
if( eglMakeCurrent(_display, _surface, _surface, _context) == EGL_FALSE )
{
LOGW("Unable to eglMakeCurrent");
return false;
}
_bContextValid = true;
return true;
}
EGLint GLContext::swap()
{
bool b = eglSwapBuffers( _display, _surface);
if( !b )
{
EGLint err = eglGetError();
if( err == EGL_BAD_SURFACE )
{
//Recreate surface
initEGLSurface();
}
else if( err == EGL_CONTEXT_LOST || err == EGL_BAD_CONTEXT )
{
//Context has been lost!!
_bContextValid = 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;
_bContextValid = false;
}
EGLint GLContext::resume(ANativeWindow* window)
{
if( _bEGLContextInitialized == false )
{
init( window );
return EGL_SUCCESS;
}
int32_t iOriginalWidth = _iWidth;
int32_t iOriginalHeight = _iHeight;
//Create surface
_window = window;
_surface = eglCreateWindowSurface( _display, _config, _window, NULL );
eglQuerySurface(_display, _surface, EGL_WIDTH, &_iWidth);
eglQuerySurface(_display, _surface, EGL_HEIGHT, &_iHeight);
if( _iWidth != iOriginalWidth || _iHeight != iOriginalHeight )
{
//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();
_bEGLContextInitialized = 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;
}

104
ndk/sources/android/helper/GLContext.h Normal file
View File

@@ -0,0 +1,104 @@
/*
* 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 <android/sensor.h>
#include <android/log.h>
#include <android_native_app_glue.h>
#include <android/native_window_jni.h>
#include "JNIHelper.h"
//--------------------------------------------------------------------------------
// 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
*/
class GLContext
{
private:
//ELG configurations
ANativeWindow* _window;
EGLDisplay _display;
EGLSurface _surface;
EGLContext _context;
EGLConfig _config;
//Screen parameters
int32_t _iWidth;
int32_t _iHeight;
int32_t _iColorSize;
int32_t _iDepthSize;
//Flags
bool _bGLESInitialized;
bool _bEGLContextInitialized;
bool _bES3Support;
float _fGLVersion;
void initGLES();
bool _bContextValid;
void terminate();
bool initEGLSurface();
bool initEGLContext();
public:
static GLContext* getInstance()
{
//Singleton
static GLContext instance;
return &instance;
}
GLContext( GLContext const& );
void operator=( GLContext const& );
GLContext();
virtual ~GLContext();
bool init( ANativeWindow* window );
EGLint swap();
bool invalidate();
void suspend();
EGLint resume(ANativeWindow* window);
int32_t getScreenWidth() { return _iWidth; }
int32_t getScreenHeight() { return _iHeight; }
int32_t getBufferColorSize() { return _iColorSize; }
int32_t getBufferDepthSize() { return _iDepthSize; }
float getGLVersion() { return _fGLVersion; }
bool checkExtension( const char* extension );
};
#endif /* GLCONTEXT_H_ */

78
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/JNIHelper.cpp → ndk/sources/android/helper/JNIHelper.cpp
View File

@@ -16,6 +16,9 @@
#include "JNIHelper.h"
#define CLASS_NAME "android/app/NativeActivity"
#define APPLICATION_CLASS_NAME "com/sample/helper/NDKHelper"
//---------------------------------------------------------------------------
//JNI Helper functions
//---------------------------------------------------------------------------
@@ -23,6 +26,7 @@
ANativeActivity* JNIHelper::_activity;
jobject JNIHelper::_objJNIHelper;
jclass JNIHelper::_clsJNIHelper;
std::string JNIHelper::_appName;
jclass retrieveClass(JNIEnv *jni, ANativeActivity* activity,
const char* className) {
@@ -41,10 +45,33 @@ jclass retrieveClass(JNIEnv *jni, ANativeActivity* activity,
return classRetrieved;
}
//---------------------------------------------------------------------------
//Init
//---------------------------------------------------------------------------
void JNIHelper::init( ANativeActivity* activity )
{
_activity = activity;
JNIEnv *env;
_activity->vm->AttachCurrentThread(&env, NULL);
//Retrieve app name
jclass android_content_Context = env->GetObjectClass(_activity->clazz);
jmethodID midGetPackageName = env->GetMethodID(android_content_Context, "getPackageName", "()Ljava/lang/String;");
jstring packageName= (jstring)env->CallObjectMethod(_activity->clazz, midGetPackageName);
const char* appname = env->GetStringUTFChars(packageName, NULL);
_appName = std::string(appname);
_activity->vm->DetachCurrentThread();
};
//---------------------------------------------------------------------------
//readFile
//---------------------------------------------------------------------------
bool JNIHelper::readFile(const char* fileName, std::vector<uint8_t>& buffer) {
bool JNIHelper::readFile(const char* fileName, std::vector<uint8_t>& buffer)
{
if (_activity == NULL) {
return false;
}
@@ -101,13 +128,13 @@ bool JNIHelper::readFile(const char* fileName, std::vector<uint8_t>& buffer) {
}
}
jstring JNIHelper::getExternalFilesDir(JNIEnv *env) {
jstring JNIHelper::getExternalFilesDir(JNIEnv *env)
{
if (_activity == NULL) {
return NULL;
}
// getExternalFilesDir() - java
jclass cls_Env = env->FindClass("android/app/NativeActivity");
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);
@@ -118,7 +145,8 @@ jstring JNIHelper::getExternalFilesDir(JNIEnv *env) {
return obj_Path;
}
uint32_t JNIHelper::loadTexture(const char* fileName) {
uint32_t JNIHelper::loadTexture(const char* fileName)
{
if (_activity == NULL) {
return 0;
}
@@ -138,12 +166,12 @@ uint32_t JNIHelper::loadTexture(const char* fileName) {
_objJNIHelper = env->NewGlobalRef(_objJNIHelper);
}
/* Ask the PNG manager for a bitmap */
mid = env->GetMethodID(_clsJNIHelper, "openBitmap",
"(Ljava/lang/String;Z)Landroid/graphics/Bitmap;");
jstring name = env->NewStringUTF(fileName);
#if 0
/* Ask the PNG manager for a bitmap */
mid = env->GetMethodID(_clsJNIHelper, "openBitmap",
"(Ljava/lang/String;Z)Landroid/graphics/Bitmap;");
jobject png = env->CallObjectMethod(_objJNIHelper, mid, name, true);
env->DeleteLocalRef(name);
env->NewGlobalRef(png);
@@ -208,3 +236,35 @@ uint32_t JNIHelper::loadTexture(const char* fileName) {
}
std::string JNIHelper::convertString( const char* str, const char* encode )
{
if (_activity == NULL)
{
return std::string("");
}
JNIEnv *env;
_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 );
_activity->vm->DetachCurrentThread();
return s;
}

37
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/JNIHelper.h → ndk/sources/android/helper/JNIHelper.h
View File

@@ -22,6 +22,7 @@
#include <map>
#include <fstream>
#include <iostream>
#include <string>
#include <EGL/egl.h>
#include <GLES2/gl2.h>
@@ -30,27 +31,29 @@
#include <android/log.h>
#include <android_native_app_glue.h>
#define APP_NAME "native-activity"
#define CLASS_NAME "android/app/NativeActivity"
#define APPLICATION_CLASS_NAME "com/sample/mmdPlay/NDKSupport"
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, APP_NAME, __VA_ARGS__))
#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, APP_NAME, __VA_ARGS__))
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, APP_NAME, __VA_ARGS__))
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, JNIHelper::getAppName(), __VA_ARGS__))
#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, JNIHelper::getAppName(), __VA_ARGS__))
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, JNIHelper::getAppName(), __VA_ARGS__))
jclass retrieveClass(JNIEnv *jni, ANativeActivity* activity, const char* className);
/******************************************************************
* Helpers to invoke Java methods
* To use this class, add NDKHelper.java as a corresponding helpers in Java side
*/
class JNIHelper
{
private:
static ANativeActivity* _activity;
static jobject _objJNIHelper;
static jclass _clsJNIHelper;
static jstring getExternalFilesDir( JNIEnv *env );
static std::string _appName;
public:
JNIHelper() {
JNIHelper()
{
};
~JNIHelper() {
JNIEnv *env;
@@ -62,14 +65,16 @@ public:
_activity->vm->DetachCurrentThread();
};
static void init( ANativeActivity* activity )
{
_activity = activity;
};
static void init( ANativeActivity* activity );
static bool readFile( const char* fileName, std::vector<uint8_t>& buffer );
static uint32_t loadTexture(const char* fileName );
static std::string convertString( const char* str, const char* encode );
static const char* getAppName() {
return _appName.c_str();
};
};

9
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/NDKSupport.h → ndk/sources/android/helper/NDKHelper.h
View File

@@ -17,11 +17,18 @@
#ifndef _NDKSUPPORT_H
#define _NDKSUPPORT_H
/******************************************************************
* NDK support helpers
*
*/
#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 detector
#include "gestureDetector.h" //Tap/Doubletap/Pinch detector
#include "perfMonitor.h" //FPS counter
#include "interpolator.h" //Interpolator
#endif

345
ndk/sources/android/helper/gestureDetector.cpp Normal file
View File

@@ -0,0 +1,345 @@
/*
* 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.cpp
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
// includes
//--------------------------------------------------------------------------------
#include "gestureDetector.h"
//--------------------------------------------------------------------------------
// GestureDetector
//--------------------------------------------------------------------------------
GestureDetector::GestureDetector()
{
_fDpFactor = 1.f;
}
void GestureDetector::setConfiguration(AConfiguration* config)
{
_fDpFactor = 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 iAction = AMotionEvent_getAction(motion_event);
unsigned int flags = iAction & AMOTION_EVENT_ACTION_MASK;
switch( flags )
{
case AMOTION_EVENT_ACTION_DOWN:
_iDownPointerID = AMotionEvent_getPointerId(motion_event, 0);
_fDownX = AMotionEvent_getX(motion_event, 0);
_fDownY = 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( _iDownPointerID == AMotionEvent_getPointerId(motion_event, 0) )
{
float fX = AMotionEvent_getX(motion_event, 0) - _fDownX;
float fY = AMotionEvent_getY(motion_event, 0) - _fDownY;
if( fX * fX + fY * fY < TOUCH_SLOP * TOUCH_SLOP * _fDpFactor )
{
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 bDetectedTap = _tapDetector.detect(motion_event);
int32_t iAction = AMotionEvent_getAction(motion_event);
unsigned int flags = iAction & AMOTION_EVENT_ACTION_MASK;
switch( flags )
{
case AMOTION_EVENT_ACTION_DOWN:
{
int64_t eventTime = AMotionEvent_getEventTime(motion_event);
if( eventTime - _lastTapTime <= DOUBLE_TAP_TIMEOUT )
{
float fX = AMotionEvent_getX(motion_event, 0) - _fLastTapX;
float fY = AMotionEvent_getY(motion_event, 0) - _fLastTapY;
if( fX * fX + fY * fY < DOUBLE_TAP_SLOP * DOUBLE_TAP_SLOP * _fDpFactor )
{
LOGI("DoubletapDetector: Doubletap detected");
return GESTURE_STATE_ACTION;
}
}
break;
}
case AMOTION_EVENT_ACTION_UP:
if( bDetectedTap )
{
_lastTapTime = AMotionEvent_getEventTime(motion_event);
_fLastTapX = AMotionEvent_getX(motion_event, 0);
_fLastTapY = AMotionEvent_getY(motion_event, 0);
}
break;
}
return GESTURE_STATE_NONE;
}
void DoubletapDetector::setConfiguration(AConfiguration* config)
{
_fDpFactor = 160.f / AConfiguration_getDensity(config);
_tapDetector.setConfiguration(config);
}
//--------------------------------------------------------------------------------
// PinchDetector
//--------------------------------------------------------------------------------
int32_t PinchDetector::findIndex( const AInputEvent* event, int32_t iID )
{
int32_t iCount = AMotionEvent_getPointerCount(event);
for( uint32_t i = 0; i < iCount; ++i )
{
if( iID == AMotionEvent_getPointerId(event, i) )
return i;
}
return -1;
}
GESTURE_STATE PinchDetector::detect(const AInputEvent* event)
{
GESTURE_STATE ret = GESTURE_STATE_NONE;
int32_t iAction = AMotionEvent_getAction(event);
uint32_t flags = iAction & AMOTION_EVENT_ACTION_MASK;
_event = event;
int32_t iCount = AMotionEvent_getPointerCount(event);
switch( flags )
{
case AMOTION_EVENT_ACTION_DOWN:
_vecPointers.push_back( AMotionEvent_getPointerId( event, 0 ) );
break;
case AMOTION_EVENT_ACTION_POINTER_DOWN:
{
int32_t iIndex = (iAction & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
_vecPointers.push_back(AMotionEvent_getPointerId(event, iIndex));
if( iCount == 2 )
{
//Start new pinch
ret = GESTURE_STATE_START;
}
}
break;
case AMOTION_EVENT_ACTION_UP:
_vecPointers.pop_back();
break;
case AMOTION_EVENT_ACTION_POINTER_UP:
{
int32_t iIndex = (iAction & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
int32_t iReleasedPointerID = AMotionEvent_getPointerId(event, iIndex);
std::vector<int32_t>::iterator it = _vecPointers.begin();
std::vector<int32_t>::iterator itEnd = _vecPointers.end();
int32_t i = 0;
for(;it!=itEnd;++it, ++i)
{
if( *it == iReleasedPointerID )
{
_vecPointers.erase(it);
break;
}
}
if( i <= 1 )
{
//Reset pinch or drag
if( iCount != 2 )
{
//Start new pinch
ret = GESTURE_STATE_START | GESTURE_STATE_END;
}
}
}
break;
case AMOTION_EVENT_ACTION_MOVE:
switch(iCount)
{
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( _vecPointers.size() < 2 )
return false;
int32_t iIndex = findIndex( _event, _vecPointers[0] );
if( iIndex == -1 )
return false;
float fX = AMotionEvent_getX( _event, iIndex);
float fY = AMotionEvent_getY( _event, iIndex);
iIndex = findIndex( _event, _vecPointers[1] );
if( iIndex == -1 )
return false;
float fX2 = AMotionEvent_getX( _event, iIndex);
float fY2 = AMotionEvent_getY( _event, iIndex);
v1 = vec2( fX, fY );
v2 = vec2( fX2, fY2 );
return true;
}
//--------------------------------------------------------------------------------
// DragDetector
//--------------------------------------------------------------------------------
int32_t DragDetector::findIndex( const AInputEvent* event, int32_t iID )
{
int32_t iCount = AMotionEvent_getPointerCount(event);
for( uint32_t i = 0; i < iCount; ++i )
{
if( iID == AMotionEvent_getPointerId(event, i) )
return i;
}
return -1;
}
GESTURE_STATE DragDetector::detect(const AInputEvent* event)
{
GESTURE_STATE ret = GESTURE_STATE_NONE;
int32_t iAction = AMotionEvent_getAction(event);
int32_t iIndex = (iAction & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
uint32_t flags = iAction & AMOTION_EVENT_ACTION_MASK;
_event = event;
int32_t iCount = AMotionEvent_getPointerCount(event);
switch( flags )
{
case AMOTION_EVENT_ACTION_DOWN:
_vecPointers.push_back( AMotionEvent_getPointerId( event, 0 ) );
ret = GESTURE_STATE_START;
break;
case AMOTION_EVENT_ACTION_POINTER_DOWN:
_vecPointers.push_back(AMotionEvent_getPointerId(event, iIndex));
break;
case AMOTION_EVENT_ACTION_UP:
_vecPointers.pop_back();
ret = GESTURE_STATE_END;
break;
case AMOTION_EVENT_ACTION_POINTER_UP:
{
int32_t iReleasedPointerID = AMotionEvent_getPointerId(event, iIndex);
std::vector<int32_t>::iterator it = _vecPointers.begin();
std::vector<int32_t>::iterator itEnd = _vecPointers.end();
int32_t i = 0;
for(;it!=itEnd;++it, ++i)
{
if( *it == iReleasedPointerID )
{
_vecPointers.erase(it);
break;
}
}
if( i <= 1 )
{
//Reset pinch or drag
if( iCount == 2 )
{
ret = GESTURE_STATE_START;
}
}
break;
}
case AMOTION_EVENT_ACTION_MOVE:
switch(iCount)
{
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( _vecPointers.size() < 1 )
return false;
int32_t iIndex = findIndex( _event, _vecPointers[0] );
if( iIndex == -1 )
return false;
float fX = AMotionEvent_getX( _event, iIndex);
float fY = AMotionEvent_getY( _event, iIndex);
v = vec2( fX, fY );
return true;
}

143
ndk/sources/android/helper/gestureDetector.h Normal file
View File

@@ -0,0 +1,143 @@
/*
* 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"
//--------------------------------------------------------------------------------
// 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;
#define GESTURE_STATE_NONE (0)
#define GESTURE_STATE_START (1)
#define GESTURE_STATE_MOVE (2)
#define GESTURE_STATE_END (4)
#define 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 _fDpFactor;
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 _iDownPointerID;
float _fDownX;
float _fDownY;
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 _tapDetector;
int64_t _lastTapTime;
float _fLastTapX;
float _fLastTapY;
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 iID );
const AInputEvent* _event;
std::vector<int32_t> _vecPointers;
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 iID );
const AInputEvent* _event;
std::vector<int32_t> _vecPointers;
public:
DragDetector() {}
virtual ~DragDetector() {}
virtual GESTURE_STATE detect(const AInputEvent* event);
bool getPointer( vec2& v );
};
#endif /* GESTUREDETECTOR_H_ */

343
ndk/sources/android/helper/gl3stub.c Normal file
View File

@@ -0,0 +1,343 @@
/*
* 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);

500
ndk/sources/android/helper/gl3stub.h Normal file
View File

@@ -0,0 +1,500 @@
#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>
#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;
typedef khronos_int64_t GLint64;
typedef khronos_uint64_t GLuint64;
typedef struct __GLsync *GLsync;
/*-------------------------------------------------------------------------
* 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

169
ndk/sources/android/helper/interpolator.cpp Normal file
View File

@@ -0,0 +1,169 @@
/*
* 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"
//-------------------------------------------------
//Ctor
//-------------------------------------------------
interpolator::interpolator()
{
m_listParams.clear();
}
//-------------------------------------------------
//Dtor
//-------------------------------------------------
interpolator::~interpolator()
{
m_listParams.clear();
}
void interpolator::clear()
{
m_listParams.clear();
}
interpolator& interpolator::set(float start,float dest, INTERPOLATOR_TYPE type, double duration)
{
//init the parameters for the interpolation process
_dStartTime = perfMonitor::getCurrentTime();
_dDestTime = _dStartTime + duration;
_type = type;
_fStartValue = start;
_fDestValue = dest;
return *this;
}
interpolator& interpolator::add(const float dest,
INTERPOLATOR_TYPE type, double duration)
{
interpolatorParam param;
param.fDestValue = dest;
param.type = type;
param.dDuration = duration;
m_listParams.push_back( param );
return *this;
}
bool interpolator::update( const double currentTime, float& p )
{
bool bContinue;
if( currentTime >= _dDestTime )
{
p = _fDestValue;
if( m_listParams.size () )
{
interpolatorParam& item = m_listParams.front();
set(_fDestValue, item.fDestValue, item.type, item.dDuration );
m_listParams.pop_front();
bContinue = true;
}
else
{
bContinue = false;
}
}
else
{
float t = (float)(currentTime - _dStartTime);
float d = (float)(_dDestTime - _dStartTime);
float b = _fStartValue;
float c = _fDestValue - _fStartValue;
p = getFormula(_type, t, b, d, c);
bContinue = true;
}
return bContinue;
}
float interpolator::getFormula(INTERPOLATOR_TYPE type, float t, float b, float d, 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;
}
}

78
ndk/sources/android/helper/interpolator.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* 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>
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 interpolatorParam {
float fDestValue;
INTERPOLATOR_TYPE type;
double dDuration;
};
/******************************************************************
* Interpolates values with several interpolation methods
*/
class interpolator {
private:
double _dStartTime;
double _dDestTime;
INTERPOLATOR_TYPE _type;
float _fStartValue;
float _fDestValue;
std::list< interpolatorParam > m_listParams;
float getFormula(INTERPOLATOR_TYPE type, float t, float b, float d, float c);
public:
interpolator();
~interpolator();
interpolator& set(const float start,
const float dest,
INTERPOLATOR_TYPE type, double duration);
interpolator& add(const float dest,
INTERPOLATOR_TYPE type, double duration);
bool update( const double currentTime, float& p );
void clear();
};
#endif /* INTERPOLATOR_H_ */

7
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/perfMonitor.cpp → ndk/sources/android/helper/perfMonitor.cpp
View File

@@ -16,11 +16,14 @@
#include "perfMonitor.h"
perfMonitor::perfMonitor():_dLastTick(0.f), _tvLastSec(0), _tickindex(0), _ticksum(0)
perfMonitor::perfMonitor():
_dLastTick(0.f),
_tvLastSec(0),
_tickindex(0),
_ticksum(0)
{
for(int32_t i = 0; i < NUM_SAMPLES; ++i )
_ticklist[i] = 0;
}
perfMonitor::~perfMonitor() {

12
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/perfMonitor.h → ndk/sources/android/helper/perfMonitor.h
View File

@@ -24,7 +24,11 @@
const int32_t NUM_SAMPLES = 100;
/******************************************************************
* Helper class for a performance monitoring and get current tick time
*/
class perfMonitor {
private:
float _fCurrentFPS;
time_t _tvLastSec;
@@ -39,6 +43,14 @@ public:
virtual ~perfMonitor();
bool update(float &fFPS);
static double getCurrentTime()
{
struct timeval Time;
gettimeofday( &Time, NULL );
double dTime = Time.tv_sec + Time.tv_usec * 1.0/1000000.0;
return dTime;
}
};
#endif /* PERFMONITOR_H_ */

76
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/shader.cpp → ndk/sources/android/helper/shader.cpp
View File

@@ -20,10 +20,8 @@
#define DEBUG (1)
bool shader::compileShader(GLuint *shader, const GLenum type,
const char *strFileName) {
GLint status;
const GLchar *source;
const char *strFileName, const std::map<std::string, std::string>& mapParameters)
{
std::vector<uint8_t> data;
bool b = JNIHelper::readFile(strFileName, data);
if (!b)
@@ -32,13 +30,31 @@ bool shader::compileShader(GLuint *shader, const GLenum type,
return false;
}
source = (GLchar *) &data[0];
if (!source) {
LOGI("Failed to load vertex shader:%s", strFileName);
return false;
//Fill-in parameters
std::string str(data.begin(), data.end());
std::map<std::string, std::string>::const_iterator it = mapParameters.begin();
std::map<std::string, std::string>::const_iterator itEnd = mapParameters.end();
while( it != itEnd )
{
size_t pos = 0;
while( (pos = str.find( it->first, pos )) != std::string::npos )
{
str.replace( pos, it->first.length(), it->second );
pos += it->second.length();
}
it++;
}
int32_t iSize = data.size();
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..
@@ -56,30 +72,54 @@ bool shader::compileShader(GLuint *shader, const GLenum type,
}
#endif
GLint status;
glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);
if (status == 0) {
glDeleteShader(*shader);
return false;
}
data.clear();
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::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);
// }
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);

16
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/shader.h → ndk/sources/android/helper/shader.h
View File

@@ -21,6 +21,8 @@
#include <errno.h>
#include <vector>
#include <map>
#include <string>
#include <EGL/egl.h>
#include <GLES/gl.h>
@@ -33,10 +35,24 @@
#include "JNIHelper.h"
/******************************************************************
* Shader compiler helper
*
* compileShader() with std::map helps patching on a shader on the fly.
* For a example,
* map : %KEY% -> %VALUE% replaces all %KEY% entries in the given shader code to %VALUE"
*
*/
class shader {
public:
static bool compileShader(GLuint *shader, const GLenum type,
std::vector<uint8_t>& data);
static bool compileShader(GLuint *shader, const GLenum type,
const GLchar *source, const int32_t iSize);
static bool compileShader(GLuint *shader, const GLenum type,
const char *strFileName);
static bool compileShader(GLuint *shader, const GLenum type,
const char *strFileName, const std::map<std::string, std::string>& mapParameters);
static bool linkProgram(const GLuint prog);
static bool validateProgram(const GLuint prog);
};

46
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/tapCamera.cpp → ndk/sources/android/helper/tapCamera.cpp
View File

@@ -34,13 +34,34 @@ const float MOMENTUM_FACTOR_THRESHOLD = 0.001f;
//----------------------------------------------------------
// Ctor
//----------------------------------------------------------
tapCamera::tapCamera():_bDragging(false), _bMomentum(false), _fBallRadius( 0.75f )
tapCamera::tapCamera():
_bDragging(false),
_bPinching( false ),
_bMomentum(false),
_fBallRadius( 0.75f ),
_fPinchStartDistanceSQ( 0.f ),
_fRotation( 0.f ),
_fRotationStart( 0.f ),
_fRotationNow( 0.f ),
_fMomentumSteps( 0.f ),
_fFlipZ( 0.f )
{
//Init offset
initParameters();
_vFlip = vec2( 1.f, -1.f );
_fFlipZ = -1.f;
_vPinchTransformFactor = vec3( 1.f, 1.f, 1.f );
_vBallCenter = vec2( 0, 0 );
_vBallNow = vec2( 0, 0 );
_vBallDown = vec2( 0, 0 );
_vecPinchStart = vec2( 0, 0 );
_vecPinchStartCenter = vec2( 0, 0 );
_vFlip = vec2( 0, 0 );
}
void tapCamera::initParameters()
@@ -49,8 +70,14 @@ void tapCamera::initParameters()
_vecOffset = vec3();
_vecOffsetNow = vec3();
_qBallNow = quaternion();
_qBallRot = quaternion();
_qBallNow = quaternion();
_qBallNow.toMatrix(_mRotation);
_fRotation = 0.f;
_vDragDelta = vec2();
_vecOffsetDelta = vec3();
_bMomentum = false;
}
@@ -99,7 +126,8 @@ void tapCamera::update()
vec3 vec = _vecOffset + _vecOffsetNow;
vec3 vecTmp(TRANSFORM_FACTOR, -TRANSFORM_FACTOR, TRANSFORM_FACTORZ);
vec *= vecTmp;
vec *= vecTmp * _vPinchTransformFactor;
_mTransform = mat4::translation(vec);
}
@@ -117,6 +145,8 @@ mat4& tapCamera::getTransformMatrix()
void tapCamera::reset(const bool bAnimate)
{
initParameters();
update();
}
//----------------------------------------------------------
@@ -207,7 +237,6 @@ void tapCamera::endPinch()
_fRotationNow = 0;
endDrag();
}
void tapCamera::pinch(const vec2& v1, const vec2& v2)
@@ -224,9 +253,16 @@ void tapCamera::pinch(const vec2& v1, const vec2& v2)
float fDistanceSQ = fXDiff * fXDiff + fYDiff * fYDiff;
float f = _fPinchStartDistanceSQ / 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 - _vecPinchStartCenter;
_vecOffsetNow = vec3( vec,
_fFlipZ * (_fPinchStartDistanceSQ / fDistanceSQ - 1.f) );
_fFlipZ * f );
//Update momentum factor
_vecOffsetDelta = _vecOffsetDelta * MOMENTUM_FACTOR + (_vecOffsetNow - _vecOffsetLast);

26
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/tapCamera.h → ndk/sources/android/helper/tapCamera.h
View File

@@ -14,10 +14,6 @@
* limitations under the License.
*/
//----------------------------------------------------------
// tapCamera.h
// Camera control with tap
//----------------------------------------------------------
#pragma once
#include <vector>
#include <string>
@@ -25,14 +21,23 @@
#include "JNIHelper.h"
#include "vecmath.h"
#include "interpolator.h"
/******************************************************************
* 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 _vBallCenter;
float _fBallRadius;
quaternion _qBallNow, _qBallDown;
vec2 _vBallNow, _vBallDown;
quaternion _qBallNow;
quaternion _qBallDown;
vec2 _vBallNow;
vec2 _vBallDown;
quaternion _qBallRot;
bool _bDragging;
@@ -69,6 +74,9 @@ class tapCamera
vec3 pointOnSphere(vec2& point);
void ballUpdate();
void initParameters();
vec3 _vPinchTransformFactor;
public:
tapCamera();
virtual ~tapCamera();
@@ -89,6 +97,12 @@ public:
_vFlip = vec2( fX, fY );
_fFlipZ = fZ;
}
void setPinchTransformFactor(const float fX, const float fY, const float fZ)
{
_vPinchTransformFactor = vec3( fX, fY, fZ);
}
void reset(const bool bAnimate);
};

2
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/vecmath.cpp → ndk/sources/android/helper/vecmath.cpp
View File

@@ -20,7 +20,6 @@
#include "vecmath.h"
//--------------------------------------------------------------------------------
// vec3
//--------------------------------------------------------------------------------
@@ -150,7 +149,6 @@ mat4 mat4::inverse()
//--------------------------------------------------------------------------------
// Misc
//--------------------------------------------------------------------------------
mat4 mat4::rotationX(
const float fAngle)
{

55
ndk/platforms/android-17/samples/Teapot/jni/NDKSupport/vecmath.h → ndk/sources/android/helper/vecmath.h
View File

@@ -20,16 +20,28 @@
#include <math.h>
#include "JNIHelper.h"
/******************************************************************
* 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;
//--------------------------------------------------------------------------------
// vec2
//--------------------------------------------------------------------------------
/******************************************************************
* 2 elements vector class
*
*/
class vec2
{
private:
float x,y;
public:
friend class vec3;
friend class vec4;
@@ -220,12 +232,15 @@ public:
}
};
//--------------------------------------------------------------------------------
// vec3
//--------------------------------------------------------------------------------
/******************************************************************
* 3 elements vector class
*
*/
class vec3
{
private:
float x,y,z;
public:
friend class vec4;
friend class mat4;
@@ -450,12 +465,15 @@ public:
}
};
//--------------------------------------------------------------------------------
// vec4
//--------------------------------------------------------------------------------
/******************************************************************
* 4 elements vector class
*
*/
class vec4
{
private:
float x,y,z,w;
public:
friend class vec3;
friend class mat4;
@@ -690,12 +708,15 @@ public:
}
};
//--------------------------------------------------------------------------------
// mat4
//--------------------------------------------------------------------------------
/******************************************************************
* 4x4 matrix
*
*/
class mat4
{
private:
float f[16];
public:
friend class vec3;
friend class vec4;
@@ -862,7 +883,6 @@ public:
void dump()
{
int32_t i = 0;
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]);
@@ -870,12 +890,15 @@ public:
}
};
//--------------------------------------------------------------------------------
// quaternion
//--------------------------------------------------------------------------------
/******************************************************************
* quaternion class
*
*/
class quaternion
{
private:
float x,y,z,w;
public:
friend class vec3;
friend class vec4;