Lose native_app_glue and ndk_helper to ndk/.
Bug: http://b/27072518 Change-Id: I0ae07cf0b34f374a8c3208d7daae632f3361271f
This commit is contained in:
Elliott Hughes
@@ -1 +1,4 @@
|
||||
include development/ndk/sources/android/native_app_glue/Android.mk
|
||||
#
|
||||
# This file is (otherwise) empty to deliberately prevent the build system
|
||||
# from building the samples below this point...
|
||||
#
|
||||
|
||||
@@ -1,10 +0,0 @@
|
||||
LOCAL_PATH:= $(call my-dir)
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_MODULE:= android_native_app_glue
|
||||
LOCAL_SRC_FILES:= android_native_app_glue.c
|
||||
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
|
||||
LOCAL_EXPORT_LDLIBS := -llog
|
||||
|
||||
include $(BUILD_STATIC_LIBRARY)
|
||||
@@ -1,13 +0,0 @@
|
||||
Copyright (C) 2016 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.
|
||||
@@ -1,441 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2010 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 <jni.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/resource.h>
|
||||
|
||||
#include "android_native_app_glue.h"
|
||||
#include <android/log.h>
|
||||
|
||||
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "threaded_app", __VA_ARGS__))
|
||||
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "threaded_app", __VA_ARGS__))
|
||||
|
||||
/* For debug builds, always enable the debug traces in this library */
|
||||
#ifndef NDEBUG
|
||||
# define LOGV(...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, "threaded_app", __VA_ARGS__))
|
||||
#else
|
||||
# define LOGV(...) ((void)0)
|
||||
#endif
|
||||
|
||||
static void free_saved_state(struct android_app* android_app) {
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
if (android_app->savedState != NULL) {
|
||||
free(android_app->savedState);
|
||||
android_app->savedState = NULL;
|
||||
android_app->savedStateSize = 0;
|
||||
}
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
}
|
||||
|
||||
int8_t android_app_read_cmd(struct android_app* android_app) {
|
||||
int8_t cmd;
|
||||
if (read(android_app->msgread, &cmd, sizeof(cmd)) == sizeof(cmd)) {
|
||||
switch (cmd) {
|
||||
case APP_CMD_SAVE_STATE:
|
||||
free_saved_state(android_app);
|
||||
break;
|
||||
}
|
||||
return cmd;
|
||||
} else {
|
||||
LOGE("No data on command pipe!");
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void print_cur_config(struct android_app* android_app) {
|
||||
char lang[2], country[2];
|
||||
AConfiguration_getLanguage(android_app->config, lang);
|
||||
AConfiguration_getCountry(android_app->config, country);
|
||||
|
||||
LOGV("Config: mcc=%d mnc=%d lang=%c%c cnt=%c%c orien=%d touch=%d dens=%d "
|
||||
"keys=%d nav=%d keysHid=%d navHid=%d sdk=%d size=%d long=%d "
|
||||
"modetype=%d modenight=%d",
|
||||
AConfiguration_getMcc(android_app->config),
|
||||
AConfiguration_getMnc(android_app->config),
|
||||
lang[0], lang[1], country[0], country[1],
|
||||
AConfiguration_getOrientation(android_app->config),
|
||||
AConfiguration_getTouchscreen(android_app->config),
|
||||
AConfiguration_getDensity(android_app->config),
|
||||
AConfiguration_getKeyboard(android_app->config),
|
||||
AConfiguration_getNavigation(android_app->config),
|
||||
AConfiguration_getKeysHidden(android_app->config),
|
||||
AConfiguration_getNavHidden(android_app->config),
|
||||
AConfiguration_getSdkVersion(android_app->config),
|
||||
AConfiguration_getScreenSize(android_app->config),
|
||||
AConfiguration_getScreenLong(android_app->config),
|
||||
AConfiguration_getUiModeType(android_app->config),
|
||||
AConfiguration_getUiModeNight(android_app->config));
|
||||
}
|
||||
|
||||
void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd) {
|
||||
switch (cmd) {
|
||||
case APP_CMD_INPUT_CHANGED:
|
||||
LOGV("APP_CMD_INPUT_CHANGED\n");
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
if (android_app->inputQueue != NULL) {
|
||||
AInputQueue_detachLooper(android_app->inputQueue);
|
||||
}
|
||||
android_app->inputQueue = android_app->pendingInputQueue;
|
||||
if (android_app->inputQueue != NULL) {
|
||||
LOGV("Attaching input queue to looper");
|
||||
AInputQueue_attachLooper(android_app->inputQueue,
|
||||
android_app->looper, LOOPER_ID_INPUT, NULL,
|
||||
&android_app->inputPollSource);
|
||||
}
|
||||
pthread_cond_broadcast(&android_app->cond);
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
break;
|
||||
|
||||
case APP_CMD_INIT_WINDOW:
|
||||
LOGV("APP_CMD_INIT_WINDOW\n");
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
android_app->window = android_app->pendingWindow;
|
||||
pthread_cond_broadcast(&android_app->cond);
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
break;
|
||||
|
||||
case APP_CMD_TERM_WINDOW:
|
||||
LOGV("APP_CMD_TERM_WINDOW\n");
|
||||
pthread_cond_broadcast(&android_app->cond);
|
||||
break;
|
||||
|
||||
case APP_CMD_RESUME:
|
||||
case APP_CMD_START:
|
||||
case APP_CMD_PAUSE:
|
||||
case APP_CMD_STOP:
|
||||
LOGV("activityState=%d\n", cmd);
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
android_app->activityState = cmd;
|
||||
pthread_cond_broadcast(&android_app->cond);
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
break;
|
||||
|
||||
case APP_CMD_CONFIG_CHANGED:
|
||||
LOGV("APP_CMD_CONFIG_CHANGED\n");
|
||||
AConfiguration_fromAssetManager(android_app->config,
|
||||
android_app->activity->assetManager);
|
||||
print_cur_config(android_app);
|
||||
break;
|
||||
|
||||
case APP_CMD_DESTROY:
|
||||
LOGV("APP_CMD_DESTROY\n");
|
||||
android_app->destroyRequested = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd) {
|
||||
switch (cmd) {
|
||||
case APP_CMD_TERM_WINDOW:
|
||||
LOGV("APP_CMD_TERM_WINDOW\n");
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
android_app->window = NULL;
|
||||
pthread_cond_broadcast(&android_app->cond);
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
break;
|
||||
|
||||
case APP_CMD_SAVE_STATE:
|
||||
LOGV("APP_CMD_SAVE_STATE\n");
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
android_app->stateSaved = 1;
|
||||
pthread_cond_broadcast(&android_app->cond);
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
break;
|
||||
|
||||
case APP_CMD_RESUME:
|
||||
free_saved_state(android_app);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void app_dummy() {
|
||||
|
||||
}
|
||||
|
||||
static void android_app_destroy(struct android_app* android_app) {
|
||||
LOGV("android_app_destroy!");
|
||||
free_saved_state(android_app);
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
if (android_app->inputQueue != NULL) {
|
||||
AInputQueue_detachLooper(android_app->inputQueue);
|
||||
}
|
||||
AConfiguration_delete(android_app->config);
|
||||
android_app->destroyed = 1;
|
||||
pthread_cond_broadcast(&android_app->cond);
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
// Can't touch android_app object after this.
|
||||
}
|
||||
|
||||
static void process_input(struct android_app* app, struct android_poll_source* source) {
|
||||
AInputEvent* event = NULL;
|
||||
while (AInputQueue_getEvent(app->inputQueue, &event) >= 0) {
|
||||
LOGV("New input event: type=%d\n", AInputEvent_getType(event));
|
||||
if (AInputQueue_preDispatchEvent(app->inputQueue, event)) {
|
||||
continue;
|
||||
}
|
||||
int32_t handled = 0;
|
||||
if (app->onInputEvent != NULL) handled = app->onInputEvent(app, event);
|
||||
AInputQueue_finishEvent(app->inputQueue, event, handled);
|
||||
}
|
||||
}
|
||||
|
||||
static void process_cmd(struct android_app* app, struct android_poll_source* source) {
|
||||
int8_t cmd = android_app_read_cmd(app);
|
||||
android_app_pre_exec_cmd(app, cmd);
|
||||
if (app->onAppCmd != NULL) app->onAppCmd(app, cmd);
|
||||
android_app_post_exec_cmd(app, cmd);
|
||||
}
|
||||
|
||||
static void* android_app_entry(void* param) {
|
||||
struct android_app* android_app = (struct android_app*)param;
|
||||
|
||||
android_app->config = AConfiguration_new();
|
||||
AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
|
||||
|
||||
print_cur_config(android_app);
|
||||
|
||||
android_app->cmdPollSource.id = LOOPER_ID_MAIN;
|
||||
android_app->cmdPollSource.app = android_app;
|
||||
android_app->cmdPollSource.process = process_cmd;
|
||||
android_app->inputPollSource.id = LOOPER_ID_INPUT;
|
||||
android_app->inputPollSource.app = android_app;
|
||||
android_app->inputPollSource.process = process_input;
|
||||
|
||||
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
|
||||
ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL,
|
||||
&android_app->cmdPollSource);
|
||||
android_app->looper = looper;
|
||||
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
android_app->running = 1;
|
||||
pthread_cond_broadcast(&android_app->cond);
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
|
||||
android_main(android_app);
|
||||
|
||||
android_app_destroy(android_app);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------
|
||||
// Native activity interaction (called from main thread)
|
||||
// --------------------------------------------------------------------
|
||||
|
||||
static struct android_app* android_app_create(ANativeActivity* activity,
|
||||
void* savedState, size_t savedStateSize) {
|
||||
struct android_app* android_app = (struct android_app*)malloc(sizeof(struct android_app));
|
||||
memset(android_app, 0, sizeof(struct android_app));
|
||||
android_app->activity = activity;
|
||||
|
||||
pthread_mutex_init(&android_app->mutex, NULL);
|
||||
pthread_cond_init(&android_app->cond, NULL);
|
||||
|
||||
if (savedState != NULL) {
|
||||
android_app->savedState = malloc(savedStateSize);
|
||||
android_app->savedStateSize = savedStateSize;
|
||||
memcpy(android_app->savedState, savedState, savedStateSize);
|
||||
}
|
||||
|
||||
int msgpipe[2];
|
||||
if (pipe(msgpipe)) {
|
||||
LOGE("could not create pipe: %s", strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
android_app->msgread = msgpipe[0];
|
||||
android_app->msgwrite = msgpipe[1];
|
||||
|
||||
pthread_attr_t attr;
|
||||
pthread_attr_init(&attr);
|
||||
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
|
||||
pthread_create(&android_app->thread, &attr, android_app_entry, android_app);
|
||||
|
||||
// Wait for thread to start.
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
while (!android_app->running) {
|
||||
pthread_cond_wait(&android_app->cond, &android_app->mutex);
|
||||
}
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
|
||||
return android_app;
|
||||
}
|
||||
|
||||
static void android_app_write_cmd(struct android_app* android_app, int8_t cmd) {
|
||||
if (write(android_app->msgwrite, &cmd, sizeof(cmd)) != sizeof(cmd)) {
|
||||
LOGE("Failure writing android_app cmd: %s\n", strerror(errno));
|
||||
}
|
||||
}
|
||||
|
||||
static void android_app_set_input(struct android_app* android_app, AInputQueue* inputQueue) {
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
android_app->pendingInputQueue = inputQueue;
|
||||
android_app_write_cmd(android_app, APP_CMD_INPUT_CHANGED);
|
||||
while (android_app->inputQueue != android_app->pendingInputQueue) {
|
||||
pthread_cond_wait(&android_app->cond, &android_app->mutex);
|
||||
}
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
}
|
||||
|
||||
static void android_app_set_window(struct android_app* android_app, ANativeWindow* window) {
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
if (android_app->pendingWindow != NULL) {
|
||||
android_app_write_cmd(android_app, APP_CMD_TERM_WINDOW);
|
||||
}
|
||||
android_app->pendingWindow = window;
|
||||
if (window != NULL) {
|
||||
android_app_write_cmd(android_app, APP_CMD_INIT_WINDOW);
|
||||
}
|
||||
while (android_app->window != android_app->pendingWindow) {
|
||||
pthread_cond_wait(&android_app->cond, &android_app->mutex);
|
||||
}
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
}
|
||||
|
||||
static void android_app_set_activity_state(struct android_app* android_app, int8_t cmd) {
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
android_app_write_cmd(android_app, cmd);
|
||||
while (android_app->activityState != cmd) {
|
||||
pthread_cond_wait(&android_app->cond, &android_app->mutex);
|
||||
}
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
}
|
||||
|
||||
static void android_app_free(struct android_app* android_app) {
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
android_app_write_cmd(android_app, APP_CMD_DESTROY);
|
||||
while (!android_app->destroyed) {
|
||||
pthread_cond_wait(&android_app->cond, &android_app->mutex);
|
||||
}
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
|
||||
close(android_app->msgread);
|
||||
close(android_app->msgwrite);
|
||||
pthread_cond_destroy(&android_app->cond);
|
||||
pthread_mutex_destroy(&android_app->mutex);
|
||||
free(android_app);
|
||||
}
|
||||
|
||||
static void onDestroy(ANativeActivity* activity) {
|
||||
LOGV("Destroy: %p\n", activity);
|
||||
android_app_free((struct android_app*)activity->instance);
|
||||
}
|
||||
|
||||
static void onStart(ANativeActivity* activity) {
|
||||
LOGV("Start: %p\n", activity);
|
||||
android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_START);
|
||||
}
|
||||
|
||||
static void onResume(ANativeActivity* activity) {
|
||||
LOGV("Resume: %p\n", activity);
|
||||
android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_RESUME);
|
||||
}
|
||||
|
||||
static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
|
||||
struct android_app* android_app = (struct android_app*)activity->instance;
|
||||
void* savedState = NULL;
|
||||
|
||||
LOGV("SaveInstanceState: %p\n", activity);
|
||||
pthread_mutex_lock(&android_app->mutex);
|
||||
android_app->stateSaved = 0;
|
||||
android_app_write_cmd(android_app, APP_CMD_SAVE_STATE);
|
||||
while (!android_app->stateSaved) {
|
||||
pthread_cond_wait(&android_app->cond, &android_app->mutex);
|
||||
}
|
||||
|
||||
if (android_app->savedState != NULL) {
|
||||
savedState = android_app->savedState;
|
||||
*outLen = android_app->savedStateSize;
|
||||
android_app->savedState = NULL;
|
||||
android_app->savedStateSize = 0;
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&android_app->mutex);
|
||||
|
||||
return savedState;
|
||||
}
|
||||
|
||||
static void onPause(ANativeActivity* activity) {
|
||||
LOGV("Pause: %p\n", activity);
|
||||
android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_PAUSE);
|
||||
}
|
||||
|
||||
static void onStop(ANativeActivity* activity) {
|
||||
LOGV("Stop: %p\n", activity);
|
||||
android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_STOP);
|
||||
}
|
||||
|
||||
static void onConfigurationChanged(ANativeActivity* activity) {
|
||||
struct android_app* android_app = (struct android_app*)activity->instance;
|
||||
LOGV("ConfigurationChanged: %p\n", activity);
|
||||
android_app_write_cmd(android_app, APP_CMD_CONFIG_CHANGED);
|
||||
}
|
||||
|
||||
static void onLowMemory(ANativeActivity* activity) {
|
||||
struct android_app* android_app = (struct android_app*)activity->instance;
|
||||
LOGV("LowMemory: %p\n", activity);
|
||||
android_app_write_cmd(android_app, APP_CMD_LOW_MEMORY);
|
||||
}
|
||||
|
||||
static void onWindowFocusChanged(ANativeActivity* activity, int focused) {
|
||||
LOGV("WindowFocusChanged: %p -- %d\n", activity, focused);
|
||||
android_app_write_cmd((struct android_app*)activity->instance,
|
||||
focused ? APP_CMD_GAINED_FOCUS : APP_CMD_LOST_FOCUS);
|
||||
}
|
||||
|
||||
static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) {
|
||||
LOGV("NativeWindowCreated: %p -- %p\n", activity, window);
|
||||
android_app_set_window((struct android_app*)activity->instance, window);
|
||||
}
|
||||
|
||||
static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) {
|
||||
LOGV("NativeWindowDestroyed: %p -- %p\n", activity, window);
|
||||
android_app_set_window((struct android_app*)activity->instance, NULL);
|
||||
}
|
||||
|
||||
static void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue) {
|
||||
LOGV("InputQueueCreated: %p -- %p\n", activity, queue);
|
||||
android_app_set_input((struct android_app*)activity->instance, queue);
|
||||
}
|
||||
|
||||
static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) {
|
||||
LOGV("InputQueueDestroyed: %p -- %p\n", activity, queue);
|
||||
android_app_set_input((struct android_app*)activity->instance, NULL);
|
||||
}
|
||||
|
||||
void ANativeActivity_onCreate(ANativeActivity* activity,
|
||||
void* savedState, size_t savedStateSize) {
|
||||
LOGV("Creating: %p\n", activity);
|
||||
activity->callbacks->onDestroy = onDestroy;
|
||||
activity->callbacks->onStart = onStart;
|
||||
activity->callbacks->onResume = onResume;
|
||||
activity->callbacks->onSaveInstanceState = onSaveInstanceState;
|
||||
activity->callbacks->onPause = onPause;
|
||||
activity->callbacks->onStop = onStop;
|
||||
activity->callbacks->onConfigurationChanged = onConfigurationChanged;
|
||||
activity->callbacks->onLowMemory = onLowMemory;
|
||||
activity->callbacks->onWindowFocusChanged = onWindowFocusChanged;
|
||||
activity->callbacks->onNativeWindowCreated = onNativeWindowCreated;
|
||||
activity->callbacks->onNativeWindowDestroyed = onNativeWindowDestroyed;
|
||||
activity->callbacks->onInputQueueCreated = onInputQueueCreated;
|
||||
activity->callbacks->onInputQueueDestroyed = onInputQueueDestroyed;
|
||||
|
||||
activity->instance = android_app_create(activity, savedState, savedStateSize);
|
||||
}
|
||||
@@ -1,349 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2010 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 _ANDROID_NATIVE_APP_GLUE_H
|
||||
#define _ANDROID_NATIVE_APP_GLUE_H
|
||||
|
||||
#include <poll.h>
|
||||
#include <pthread.h>
|
||||
#include <sched.h>
|
||||
|
||||
#include <android/configuration.h>
|
||||
#include <android/looper.h>
|
||||
#include <android/native_activity.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* The native activity interface provided by <android/native_activity.h>
|
||||
* is based on a set of application-provided callbacks that will be called
|
||||
* by the Activity's main thread when certain events occur.
|
||||
*
|
||||
* This means that each one of this callbacks _should_ _not_ block, or they
|
||||
* risk having the system force-close the application. This programming
|
||||
* model is direct, lightweight, but constraining.
|
||||
*
|
||||
* The 'android_native_app_glue' static library is used to provide a different
|
||||
* execution model where the application can implement its own main event
|
||||
* loop in a different thread instead. Here's how it works:
|
||||
*
|
||||
* 1/ The application must provide a function named "android_main()" that
|
||||
* will be called when the activity is created, in a new thread that is
|
||||
* distinct from the activity's main thread.
|
||||
*
|
||||
* 2/ android_main() receives a pointer to a valid "android_app" structure
|
||||
* that contains references to other important objects, e.g. the
|
||||
* ANativeActivity obejct instance the application is running in.
|
||||
*
|
||||
* 3/ the "android_app" object holds an ALooper instance that already
|
||||
* listens to two important things:
|
||||
*
|
||||
* - activity lifecycle events (e.g. "pause", "resume"). See APP_CMD_XXX
|
||||
* declarations below.
|
||||
*
|
||||
* - input events coming from the AInputQueue attached to the activity.
|
||||
*
|
||||
* Each of these correspond to an ALooper identifier returned by
|
||||
* ALooper_pollOnce with values of LOOPER_ID_MAIN and LOOPER_ID_INPUT,
|
||||
* respectively.
|
||||
*
|
||||
* Your application can use the same ALooper to listen to additional
|
||||
* file-descriptors. They can either be callback based, or with return
|
||||
* identifiers starting with LOOPER_ID_USER.
|
||||
*
|
||||
* 4/ Whenever you receive a LOOPER_ID_MAIN or LOOPER_ID_INPUT event,
|
||||
* the returned data will point to an android_poll_source structure. You
|
||||
* can call the process() function on it, and fill in android_app->onAppCmd
|
||||
* and android_app->onInputEvent to be called for your own processing
|
||||
* of the event.
|
||||
*
|
||||
* Alternatively, you can call the low-level functions to read and process
|
||||
* the data directly... look at the process_cmd() and process_input()
|
||||
* implementations in the glue to see how to do this.
|
||||
*
|
||||
* See the sample named "native-activity" that comes with the NDK with a
|
||||
* full usage example. Also look at the JavaDoc of NativeActivity.
|
||||
*/
|
||||
|
||||
struct android_app;
|
||||
|
||||
/**
|
||||
* Data associated with an ALooper fd that will be returned as the "outData"
|
||||
* when that source has data ready.
|
||||
*/
|
||||
struct android_poll_source {
|
||||
// The identifier of this source. May be LOOPER_ID_MAIN or
|
||||
// LOOPER_ID_INPUT.
|
||||
int32_t id;
|
||||
|
||||
// The android_app this ident is associated with.
|
||||
struct android_app* app;
|
||||
|
||||
// Function to call to perform the standard processing of data from
|
||||
// this source.
|
||||
void (*process)(struct android_app* app, struct android_poll_source* source);
|
||||
};
|
||||
|
||||
/**
|
||||
* This is the interface for the standard glue code of a threaded
|
||||
* application. In this model, the application's code is running
|
||||
* in its own thread separate from the main thread of the process.
|
||||
* It is not required that this thread be associated with the Java
|
||||
* VM, although it will need to be in order to make JNI calls any
|
||||
* Java objects.
|
||||
*/
|
||||
struct android_app {
|
||||
// The application can place a pointer to its own state object
|
||||
// here if it likes.
|
||||
void* userData;
|
||||
|
||||
// Fill this in with the function to process main app commands (APP_CMD_*)
|
||||
void (*onAppCmd)(struct android_app* app, int32_t cmd);
|
||||
|
||||
// Fill this in with the function to process input events. At this point
|
||||
// the event has already been pre-dispatched, and it will be finished upon
|
||||
// return. Return 1 if you have handled the event, 0 for any default
|
||||
// dispatching.
|
||||
int32_t (*onInputEvent)(struct android_app* app, AInputEvent* event);
|
||||
|
||||
// The ANativeActivity object instance that this app is running in.
|
||||
ANativeActivity* activity;
|
||||
|
||||
// The current configuration the app is running in.
|
||||
AConfiguration* config;
|
||||
|
||||
// This is the last instance's saved state, as provided at creation time.
|
||||
// It is NULL if there was no state. You can use this as you need; the
|
||||
// memory will remain around until you call android_app_exec_cmd() for
|
||||
// APP_CMD_RESUME, at which point it will be freed and savedState set to NULL.
|
||||
// These variables should only be changed when processing a APP_CMD_SAVE_STATE,
|
||||
// at which point they will be initialized to NULL and you can malloc your
|
||||
// state and place the information here. In that case the memory will be
|
||||
// freed for you later.
|
||||
void* savedState;
|
||||
size_t savedStateSize;
|
||||
|
||||
// The ALooper associated with the app's thread.
|
||||
ALooper* looper;
|
||||
|
||||
// When non-NULL, this is the input queue from which the app will
|
||||
// receive user input events.
|
||||
AInputQueue* inputQueue;
|
||||
|
||||
// When non-NULL, this is the window surface that the app can draw in.
|
||||
ANativeWindow* window;
|
||||
|
||||
// Current content rectangle of the window; this is the area where the
|
||||
// window's content should be placed to be seen by the user.
|
||||
ARect contentRect;
|
||||
|
||||
// Current state of the app's activity. May be either APP_CMD_START,
|
||||
// APP_CMD_RESUME, APP_CMD_PAUSE, or APP_CMD_STOP; see below.
|
||||
int activityState;
|
||||
|
||||
// This is non-zero when the application's NativeActivity is being
|
||||
// destroyed and waiting for the app thread to complete.
|
||||
int destroyRequested;
|
||||
|
||||
// -------------------------------------------------
|
||||
// Below are "private" implementation of the glue code.
|
||||
|
||||
pthread_mutex_t mutex;
|
||||
pthread_cond_t cond;
|
||||
|
||||
int msgread;
|
||||
int msgwrite;
|
||||
|
||||
pthread_t thread;
|
||||
|
||||
struct android_poll_source cmdPollSource;
|
||||
struct android_poll_source inputPollSource;
|
||||
|
||||
int running;
|
||||
int stateSaved;
|
||||
int destroyed;
|
||||
int redrawNeeded;
|
||||
AInputQueue* pendingInputQueue;
|
||||
ANativeWindow* pendingWindow;
|
||||
ARect pendingContentRect;
|
||||
};
|
||||
|
||||
enum {
|
||||
/**
|
||||
* Looper data ID of commands coming from the app's main thread, which
|
||||
* is returned as an identifier from ALooper_pollOnce(). The data for this
|
||||
* identifier is a pointer to an android_poll_source structure.
|
||||
* These can be retrieved and processed with android_app_read_cmd()
|
||||
* and android_app_exec_cmd().
|
||||
*/
|
||||
LOOPER_ID_MAIN = 1,
|
||||
|
||||
/**
|
||||
* Looper data ID of events coming from the AInputQueue of the
|
||||
* application's window, which is returned as an identifier from
|
||||
* ALooper_pollOnce(). The data for this identifier is a pointer to an
|
||||
* android_poll_source structure. These can be read via the inputQueue
|
||||
* object of android_app.
|
||||
*/
|
||||
LOOPER_ID_INPUT = 2,
|
||||
|
||||
/**
|
||||
* Start of user-defined ALooper identifiers.
|
||||
*/
|
||||
LOOPER_ID_USER = 3,
|
||||
};
|
||||
|
||||
enum {
|
||||
/**
|
||||
* Command from main thread: the AInputQueue has changed. Upon processing
|
||||
* this command, android_app->inputQueue will be updated to the new queue
|
||||
* (or NULL).
|
||||
*/
|
||||
APP_CMD_INPUT_CHANGED,
|
||||
|
||||
/**
|
||||
* Command from main thread: a new ANativeWindow is ready for use. Upon
|
||||
* receiving this command, android_app->window will contain the new window
|
||||
* surface.
|
||||
*/
|
||||
APP_CMD_INIT_WINDOW,
|
||||
|
||||
/**
|
||||
* Command from main thread: the existing ANativeWindow needs to be
|
||||
* terminated. Upon receiving this command, android_app->window still
|
||||
* contains the existing window; after calling android_app_exec_cmd
|
||||
* it will be set to NULL.
|
||||
*/
|
||||
APP_CMD_TERM_WINDOW,
|
||||
|
||||
/**
|
||||
* Command from main thread: the current ANativeWindow has been resized.
|
||||
* Please redraw with its new size.
|
||||
*/
|
||||
APP_CMD_WINDOW_RESIZED,
|
||||
|
||||
/**
|
||||
* Command from main thread: the system needs that the current ANativeWindow
|
||||
* be redrawn. You should redraw the window before handing this to
|
||||
* android_app_exec_cmd() in order to avoid transient drawing glitches.
|
||||
*/
|
||||
APP_CMD_WINDOW_REDRAW_NEEDED,
|
||||
|
||||
/**
|
||||
* Command from main thread: the content area of the window has changed,
|
||||
* such as from the soft input window being shown or hidden. You can
|
||||
* find the new content rect in android_app::contentRect.
|
||||
*/
|
||||
APP_CMD_CONTENT_RECT_CHANGED,
|
||||
|
||||
/**
|
||||
* Command from main thread: the app's activity window has gained
|
||||
* input focus.
|
||||
*/
|
||||
APP_CMD_GAINED_FOCUS,
|
||||
|
||||
/**
|
||||
* Command from main thread: the app's activity window has lost
|
||||
* input focus.
|
||||
*/
|
||||
APP_CMD_LOST_FOCUS,
|
||||
|
||||
/**
|
||||
* Command from main thread: the current device configuration has changed.
|
||||
*/
|
||||
APP_CMD_CONFIG_CHANGED,
|
||||
|
||||
/**
|
||||
* Command from main thread: the system is running low on memory.
|
||||
* Try to reduce your memory use.
|
||||
*/
|
||||
APP_CMD_LOW_MEMORY,
|
||||
|
||||
/**
|
||||
* Command from main thread: the app's activity has been started.
|
||||
*/
|
||||
APP_CMD_START,
|
||||
|
||||
/**
|
||||
* Command from main thread: the app's activity has been resumed.
|
||||
*/
|
||||
APP_CMD_RESUME,
|
||||
|
||||
/**
|
||||
* Command from main thread: the app should generate a new saved state
|
||||
* for itself, to restore from later if needed. If you have saved state,
|
||||
* allocate it with malloc and place it in android_app.savedState with
|
||||
* the size in android_app.savedStateSize. The will be freed for you
|
||||
* later.
|
||||
*/
|
||||
APP_CMD_SAVE_STATE,
|
||||
|
||||
/**
|
||||
* Command from main thread: the app's activity has been paused.
|
||||
*/
|
||||
APP_CMD_PAUSE,
|
||||
|
||||
/**
|
||||
* Command from main thread: the app's activity has been stopped.
|
||||
*/
|
||||
APP_CMD_STOP,
|
||||
|
||||
/**
|
||||
* Command from main thread: the app's activity is being destroyed,
|
||||
* and waiting for the app thread to clean up and exit before proceeding.
|
||||
*/
|
||||
APP_CMD_DESTROY,
|
||||
};
|
||||
|
||||
/**
|
||||
* Call when ALooper_pollAll() returns LOOPER_ID_MAIN, reading the next
|
||||
* app command message.
|
||||
*/
|
||||
int8_t android_app_read_cmd(struct android_app* android_app);
|
||||
|
||||
/**
|
||||
* Call with the command returned by android_app_read_cmd() to do the
|
||||
* initial pre-processing of the given command. You can perform your own
|
||||
* actions for the command after calling this function.
|
||||
*/
|
||||
void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd);
|
||||
|
||||
/**
|
||||
* Call with the command returned by android_app_read_cmd() to do the
|
||||
* final post-processing of the given command. You must have done your own
|
||||
* actions for the command before calling this function.
|
||||
*/
|
||||
void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd);
|
||||
|
||||
/**
|
||||
* Dummy function you can call to ensure glue code isn't stripped.
|
||||
*/
|
||||
void app_dummy();
|
||||
|
||||
/**
|
||||
* This is the function that application code must implement, representing
|
||||
* the main entry to the app.
|
||||
*/
|
||||
extern void android_main(struct android_app* app);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _ANDROID_NATIVE_APP_GLUE_H */
|
||||
@@ -1,16 +0,0 @@
|
||||
LOCAL_PATH:= $(call my-dir)
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_MODULE:= ndk_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)
|
||||
@@ -1,294 +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.
|
||||
*/
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// GLContext.cpp
|
||||
//--------------------------------------------------------------------------------
|
||||
//--------------------------------------------------------------------------------
|
||||
// includes
|
||||
//--------------------------------------------------------------------------------
|
||||
#include <unistd.h>
|
||||
#include "GLContext.h"
|
||||
#include "gl3stub.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// eGLContext
|
||||
//--------------------------------------------------------------------------------
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// Ctor
|
||||
//--------------------------------------------------------------------------------
|
||||
GLContext::GLContext() :
|
||||
display_( EGL_NO_DISPLAY ),
|
||||
surface_( EGL_NO_SURFACE ),
|
||||
context_( EGL_NO_CONTEXT ),
|
||||
screen_width_( 0 ),
|
||||
screen_height_( 0 ),
|
||||
es3_supported_( false ),
|
||||
egl_context_initialized_( false ),
|
||||
gles_initialized_( false )
|
||||
{
|
||||
}
|
||||
|
||||
void GLContext::InitGLES()
|
||||
{
|
||||
if( gles_initialized_ )
|
||||
return;
|
||||
//
|
||||
//Initialize OpenGL ES 3 if available
|
||||
//
|
||||
const char* versionStr = (const char*) glGetString( GL_VERSION );
|
||||
if( strstr( versionStr, "OpenGL ES 3." ) && gl3stubInit() )
|
||||
{
|
||||
es3_supported_ = true;
|
||||
gl_version_ = 3.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
gl_version_ = 2.0f;
|
||||
}
|
||||
|
||||
gles_initialized_ = true;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// Dtor
|
||||
//--------------------------------------------------------------------------------
|
||||
GLContext::~GLContext()
|
||||
{
|
||||
Terminate();
|
||||
}
|
||||
|
||||
bool GLContext::Init( ANativeWindow* window )
|
||||
{
|
||||
if( egl_context_initialized_ )
|
||||
return true;
|
||||
|
||||
//
|
||||
//Initialize EGL
|
||||
//
|
||||
window_ = window;
|
||||
InitEGLSurface();
|
||||
InitEGLContext();
|
||||
InitGLES();
|
||||
|
||||
egl_context_initialized_ = true;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GLContext::InitEGLSurface()
|
||||
{
|
||||
display_ = eglGetDisplay( EGL_DEFAULT_DISPLAY );
|
||||
eglInitialize( display_, 0, 0 );
|
||||
|
||||
/*
|
||||
* Here specify the attributes of the desired configuration.
|
||||
* Below, we select an EGLConfig with at least 8 bits per color
|
||||
* component compatible with on-screen windows
|
||||
*/
|
||||
const EGLint attribs[] = { EGL_RENDERABLE_TYPE,
|
||||
EGL_OPENGL_ES2_BIT, //Request opengl ES2.0
|
||||
EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_BLUE_SIZE, 8, EGL_GREEN_SIZE, 8,
|
||||
EGL_RED_SIZE, 8, EGL_DEPTH_SIZE, 24, EGL_NONE };
|
||||
color_size_ = 8;
|
||||
depth_size_ = 24;
|
||||
|
||||
EGLint num_configs;
|
||||
eglChooseConfig( display_, attribs, &config_, 1, &num_configs );
|
||||
|
||||
if( !num_configs )
|
||||
{
|
||||
//Fall back to 16bit depth buffer
|
||||
const EGLint attribs[] = { EGL_RENDERABLE_TYPE,
|
||||
EGL_OPENGL_ES2_BIT, //Request opengl ES2.0
|
||||
EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_BLUE_SIZE, 8, EGL_GREEN_SIZE, 8,
|
||||
EGL_RED_SIZE, 8, EGL_DEPTH_SIZE, 16, EGL_NONE };
|
||||
eglChooseConfig( display_, attribs, &config_, 1, &num_configs );
|
||||
depth_size_ = 16;
|
||||
}
|
||||
|
||||
if( !num_configs )
|
||||
{
|
||||
LOGW( "Unable to retrieve EGL config" );
|
||||
return false;
|
||||
}
|
||||
|
||||
surface_ = eglCreateWindowSurface( display_, config_, window_, NULL );
|
||||
eglQuerySurface( display_, surface_, EGL_WIDTH, &screen_width_ );
|
||||
eglQuerySurface( display_, surface_, EGL_HEIGHT, &screen_height_ );
|
||||
|
||||
/* 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 context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, //Request opengl ES2.0
|
||||
EGL_NONE };
|
||||
context_ = eglCreateContext( display_, config_, NULL, context_attribs );
|
||||
|
||||
if( eglMakeCurrent( display_, surface_, surface_, context_ ) == EGL_FALSE )
|
||||
{
|
||||
LOGW( "Unable to eglMakeCurrent" );
|
||||
return false;
|
||||
}
|
||||
|
||||
context_valid_ = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
EGLint GLContext::Swap()
|
||||
{
|
||||
bool b = eglSwapBuffers( display_, surface_ );
|
||||
if( !b )
|
||||
{
|
||||
EGLint err = eglGetError();
|
||||
if( err == EGL_BAD_SURFACE )
|
||||
{
|
||||
//Recreate surface
|
||||
InitEGLSurface();
|
||||
return EGL_SUCCESS; //Still consider glContext is valid
|
||||
}
|
||||
else if( err == EGL_CONTEXT_LOST || err == EGL_BAD_CONTEXT )
|
||||
{
|
||||
//Context has been lost!!
|
||||
context_valid_ = false;
|
||||
Terminate();
|
||||
InitEGLContext();
|
||||
}
|
||||
return err;
|
||||
}
|
||||
return EGL_SUCCESS;
|
||||
}
|
||||
|
||||
void GLContext::Terminate()
|
||||
{
|
||||
if( display_ != EGL_NO_DISPLAY )
|
||||
{
|
||||
eglMakeCurrent( display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
|
||||
if( context_ != EGL_NO_CONTEXT )
|
||||
{
|
||||
eglDestroyContext( display_, context_ );
|
||||
}
|
||||
|
||||
if( surface_ != EGL_NO_SURFACE )
|
||||
{
|
||||
eglDestroySurface( display_, surface_ );
|
||||
}
|
||||
eglTerminate( display_ );
|
||||
}
|
||||
|
||||
display_ = EGL_NO_DISPLAY;
|
||||
context_ = EGL_NO_CONTEXT;
|
||||
surface_ = EGL_NO_SURFACE;
|
||||
context_valid_ = false;
|
||||
|
||||
}
|
||||
|
||||
EGLint GLContext::Resume( ANativeWindow* window )
|
||||
{
|
||||
if( egl_context_initialized_ == false )
|
||||
{
|
||||
Init( window );
|
||||
return EGL_SUCCESS;
|
||||
}
|
||||
|
||||
int32_t original_widhth = screen_width_;
|
||||
int32_t original_height = screen_height_;
|
||||
|
||||
//Create surface
|
||||
window_ = window;
|
||||
surface_ = eglCreateWindowSurface( display_, config_, window_, NULL );
|
||||
eglQuerySurface( display_, surface_, EGL_WIDTH, &screen_width_ );
|
||||
eglQuerySurface( display_, surface_, EGL_HEIGHT, &screen_height_ );
|
||||
|
||||
if( screen_width_ != original_widhth || screen_height_ != original_height )
|
||||
{
|
||||
//Screen resized
|
||||
LOGI( "Screen resized" );
|
||||
}
|
||||
|
||||
if( eglMakeCurrent( display_, surface_, surface_, context_ ) == EGL_TRUE )
|
||||
return EGL_SUCCESS;
|
||||
|
||||
EGLint err = eglGetError();
|
||||
LOGW( "Unable to eglMakeCurrent %d", err );
|
||||
|
||||
if( err == EGL_CONTEXT_LOST )
|
||||
{
|
||||
//Recreate context
|
||||
LOGI( "Re-creating egl context" );
|
||||
InitEGLContext();
|
||||
}
|
||||
else
|
||||
{
|
||||
//Recreate surface
|
||||
Terminate();
|
||||
InitEGLSurface();
|
||||
InitEGLContext();
|
||||
}
|
||||
|
||||
return err;
|
||||
|
||||
}
|
||||
|
||||
void GLContext::Suspend()
|
||||
{
|
||||
if( surface_ != EGL_NO_SURFACE )
|
||||
{
|
||||
eglDestroySurface( display_, surface_ );
|
||||
surface_ = EGL_NO_SURFACE;
|
||||
}
|
||||
}
|
||||
|
||||
bool GLContext::Invalidate()
|
||||
{
|
||||
Terminate();
|
||||
|
||||
egl_context_initialized_ = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GLContext::CheckExtension( const char* extension )
|
||||
{
|
||||
if( extension == NULL )
|
||||
return false;
|
||||
|
||||
std::string extensions = std::string( (char*) glGetString( GL_EXTENSIONS ) );
|
||||
std::string str = std::string( extension );
|
||||
str.append( " " );
|
||||
|
||||
size_t pos = 0;
|
||||
if( extensions.find( extension, pos ) != std::string::npos )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
} //namespace ndkHelper
|
||||
@@ -1,125 +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.
|
||||
*/
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// GLContext.h
|
||||
//--------------------------------------------------------------------------------
|
||||
#ifndef GLCONTEXT_H_
|
||||
#define GLCONTEXT_H_
|
||||
|
||||
#include <EGL/egl.h>
|
||||
#include <GLES2/gl2.h>
|
||||
#include <android/log.h>
|
||||
|
||||
#include "JNIHelper.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// Constants
|
||||
//--------------------------------------------------------------------------------
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// Class
|
||||
//--------------------------------------------------------------------------------
|
||||
|
||||
/******************************************************************
|
||||
* OpenGL context handler
|
||||
* The class handles OpenGL and EGL context based on Android activity life cycle
|
||||
* The caller needs to call corresponding methods for each activity life cycle events as it's done in sample codes.
|
||||
*
|
||||
* Also the class initializes OpenGL ES3 when the compatible driver is installed in the device.
|
||||
* getGLVersion() returns 3.0~ when the device supports OpenGLES3.0
|
||||
*
|
||||
* Thread safety: OpenGL context is expecting used within dedicated single thread,
|
||||
* thus GLContext class is not designed as a thread-safe
|
||||
*/
|
||||
class GLContext
|
||||
{
|
||||
private:
|
||||
//EGL configurations
|
||||
ANativeWindow* window_;
|
||||
EGLDisplay display_;
|
||||
EGLSurface surface_;
|
||||
EGLContext context_;
|
||||
EGLConfig config_;
|
||||
|
||||
//Screen parameters
|
||||
int32_t screen_width_;
|
||||
int32_t screen_height_;
|
||||
int32_t color_size_;
|
||||
int32_t depth_size_;
|
||||
|
||||
//Flags
|
||||
bool gles_initialized_;
|
||||
bool egl_context_initialized_;
|
||||
bool es3_supported_;
|
||||
float gl_version_;
|
||||
bool context_valid_;
|
||||
|
||||
void InitGLES();
|
||||
void Terminate();
|
||||
bool InitEGLSurface();
|
||||
bool InitEGLContext();
|
||||
|
||||
GLContext( GLContext const& );
|
||||
void operator=( GLContext const& );
|
||||
GLContext();
|
||||
virtual ~GLContext();
|
||||
public:
|
||||
static GLContext* GetInstance()
|
||||
{
|
||||
//Singleton
|
||||
static GLContext instance;
|
||||
|
||||
return &instance;
|
||||
}
|
||||
|
||||
bool Init( ANativeWindow* window );
|
||||
EGLint Swap();
|
||||
bool Invalidate();
|
||||
|
||||
void Suspend();
|
||||
EGLint Resume( ANativeWindow* window );
|
||||
|
||||
int32_t GetScreenWidth()
|
||||
{
|
||||
return screen_width_;
|
||||
}
|
||||
int32_t GetScreenHeight()
|
||||
{
|
||||
return screen_height_;
|
||||
}
|
||||
|
||||
int32_t GetBufferColorSize()
|
||||
{
|
||||
return color_size_;
|
||||
}
|
||||
int32_t GetBufferDepthSize()
|
||||
{
|
||||
return depth_size_;
|
||||
}
|
||||
float GetGLVersion()
|
||||
{
|
||||
return gl_version_;
|
||||
}
|
||||
bool CheckExtension( const char* extension );
|
||||
};
|
||||
|
||||
} //namespace ndkHelper
|
||||
|
||||
#endif /* GLCONTEXT_H_ */
|
||||
@@ -1,376 +0,0 @@
|
||||
/*
|
||||
* Copyright 2013 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include <EGL/egl.h>
|
||||
#include <GLES2/gl2.h>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
|
||||
#include "JNIHelper.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
#define CLASS_NAME "android/app/NativeActivity"
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//JNI Helper functions
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//Singleton
|
||||
//---------------------------------------------------------------------------
|
||||
JNIHelper* JNIHelper::GetInstance()
|
||||
{
|
||||
static JNIHelper helper;
|
||||
return &helper;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//Ctor
|
||||
//---------------------------------------------------------------------------
|
||||
JNIHelper::JNIHelper()
|
||||
{
|
||||
pthread_mutex_init( &mutex_, NULL );
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//Dtor
|
||||
//---------------------------------------------------------------------------
|
||||
JNIHelper::~JNIHelper()
|
||||
{
|
||||
pthread_mutex_lock( &mutex_ );
|
||||
|
||||
JNIEnv *env;
|
||||
activity_->vm->AttachCurrentThread( &env, NULL );
|
||||
|
||||
env->DeleteGlobalRef( jni_helper_java_ref_ );
|
||||
env->DeleteGlobalRef( jni_helper_java_class_ );
|
||||
|
||||
activity_->vm->DetachCurrentThread();
|
||||
|
||||
pthread_mutex_destroy( &mutex_ );
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//Init
|
||||
//---------------------------------------------------------------------------
|
||||
void JNIHelper::Init( ANativeActivity* activity,
|
||||
const char* helper_class_name )
|
||||
{
|
||||
JNIHelper& helper = *GetInstance();
|
||||
pthread_mutex_lock( &helper.mutex_ );
|
||||
|
||||
helper.activity_ = activity;
|
||||
|
||||
JNIEnv *env;
|
||||
helper.activity_->vm->AttachCurrentThread( &env, NULL );
|
||||
|
||||
//Retrieve app name
|
||||
jclass android_content_Context = env->GetObjectClass( helper.activity_->clazz );
|
||||
jmethodID midGetPackageName = env->GetMethodID( android_content_Context, "getPackageName",
|
||||
"()Ljava/lang/String;" );
|
||||
|
||||
jstring packageName = (jstring) env->CallObjectMethod( helper.activity_->clazz,
|
||||
midGetPackageName );
|
||||
const char* appname = env->GetStringUTFChars( packageName, NULL );
|
||||
helper.app_name_ = std::string( appname );
|
||||
|
||||
jclass cls = helper.RetrieveClass( env, helper_class_name );
|
||||
helper.jni_helper_java_class_ = (jclass) env->NewGlobalRef( cls );
|
||||
|
||||
jmethodID constructor = env->GetMethodID( helper.jni_helper_java_class_, "<init>", "()V" );
|
||||
helper.jni_helper_java_ref_ = env->NewObject( helper.jni_helper_java_class_, constructor );
|
||||
helper.jni_helper_java_ref_ = env->NewGlobalRef( helper.jni_helper_java_ref_ );
|
||||
|
||||
env->ReleaseStringUTFChars( packageName, appname );
|
||||
helper.activity_->vm->DetachCurrentThread();
|
||||
|
||||
pthread_mutex_unlock( &helper.mutex_ );
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//readFile
|
||||
//---------------------------------------------------------------------------
|
||||
bool JNIHelper::ReadFile( const char* fileName,
|
||||
std::vector<uint8_t>* buffer_ref )
|
||||
{
|
||||
if( activity_ == NULL )
|
||||
{
|
||||
LOGI( "JNIHelper has not been initialized.Call init() to initialize the helper" );
|
||||
return false;
|
||||
}
|
||||
|
||||
//First, try reading from externalFileDir;
|
||||
JNIEnv *env;
|
||||
jmethodID mid;
|
||||
|
||||
pthread_mutex_lock( &mutex_ );
|
||||
activity_->vm->AttachCurrentThread( &env, NULL );
|
||||
|
||||
jstring str_path = GetExternalFilesDirJString( env );
|
||||
const char* path = env->GetStringUTFChars( str_path, NULL );
|
||||
std::string s( path );
|
||||
|
||||
if( fileName[0] != '/' )
|
||||
{
|
||||
s.append( "/" );
|
||||
}
|
||||
s.append( fileName );
|
||||
std::ifstream f( s.c_str(), std::ios::binary );
|
||||
|
||||
env->ReleaseStringUTFChars( str_path, path );
|
||||
env->DeleteLocalRef( str_path );
|
||||
activity_->vm->DetachCurrentThread();
|
||||
|
||||
if( f )
|
||||
{
|
||||
LOGI( "reading:%s", s.c_str() );
|
||||
f.seekg( 0, std::ifstream::end );
|
||||
int32_t fileSize = f.tellg();
|
||||
f.seekg( 0, std::ifstream::beg );
|
||||
buffer_ref->reserve( fileSize );
|
||||
buffer_ref->assign( std::istreambuf_iterator<char>( f ), std::istreambuf_iterator<char>() );
|
||||
f.close();
|
||||
pthread_mutex_unlock( &mutex_ );
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
//Fallback to assetManager
|
||||
AAssetManager* assetManager = activity_->assetManager;
|
||||
AAsset* assetFile = AAssetManager_open( assetManager, fileName, AASSET_MODE_BUFFER );
|
||||
if( !assetFile )
|
||||
{
|
||||
pthread_mutex_unlock( &mutex_ );
|
||||
return false;
|
||||
}
|
||||
uint8_t* data = (uint8_t*) AAsset_getBuffer( assetFile );
|
||||
int32_t size = AAsset_getLength( assetFile );
|
||||
if( data == NULL )
|
||||
{
|
||||
AAsset_close( assetFile );
|
||||
|
||||
LOGI( "Failed to load:%s", fileName );
|
||||
pthread_mutex_unlock( &mutex_ );
|
||||
return false;
|
||||
}
|
||||
|
||||
buffer_ref->reserve( size );
|
||||
buffer_ref->assign( data, data + size );
|
||||
|
||||
AAsset_close( assetFile );
|
||||
pthread_mutex_unlock( &mutex_ );
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
std::string JNIHelper::GetExternalFilesDir()
|
||||
{
|
||||
if( activity_ == NULL )
|
||||
{
|
||||
LOGI( "JNIHelper has not been initialized. Call init() to initialize the helper" );
|
||||
return std::string( "" );
|
||||
}
|
||||
|
||||
pthread_mutex_lock( &mutex_ );
|
||||
|
||||
//First, try reading from externalFileDir;
|
||||
JNIEnv *env;
|
||||
jmethodID mid;
|
||||
|
||||
activity_->vm->AttachCurrentThread( &env, NULL );
|
||||
|
||||
jstring strPath = GetExternalFilesDirJString( env );
|
||||
const char* path = env->GetStringUTFChars( strPath, NULL );
|
||||
std::string s( path );
|
||||
|
||||
env->ReleaseStringUTFChars( strPath, path );
|
||||
env->DeleteLocalRef( strPath );
|
||||
activity_->vm->DetachCurrentThread();
|
||||
|
||||
pthread_mutex_unlock( &mutex_ );
|
||||
return s;
|
||||
}
|
||||
|
||||
uint32_t JNIHelper::LoadTexture( const char* file_name )
|
||||
{
|
||||
if( activity_ == NULL )
|
||||
{
|
||||
LOGI( "JNIHelper has not been initialized. Call init() to initialize the helper" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
JNIEnv *env;
|
||||
jmethodID mid;
|
||||
|
||||
pthread_mutex_lock( &mutex_ );
|
||||
activity_->vm->AttachCurrentThread( &env, NULL );
|
||||
|
||||
jstring name = env->NewStringUTF( file_name );
|
||||
|
||||
GLuint tex;
|
||||
glGenTextures( 1, &tex );
|
||||
glBindTexture( GL_TEXTURE_2D, tex );
|
||||
|
||||
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );
|
||||
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
|
||||
|
||||
mid = env->GetMethodID( jni_helper_java_class_, "loadTexture", "(Ljava/lang/String;)Z" );
|
||||
jboolean ret = env->CallBooleanMethod( jni_helper_java_ref_, mid, name );
|
||||
if( !ret )
|
||||
{
|
||||
glDeleteTextures( 1, &tex );
|
||||
tex = -1;
|
||||
LOGI( "Texture load failed %s", file_name );
|
||||
}
|
||||
|
||||
//Generate mipmap
|
||||
glGenerateMipmap( GL_TEXTURE_2D );
|
||||
|
||||
env->DeleteLocalRef( name );
|
||||
activity_->vm->DetachCurrentThread();
|
||||
pthread_mutex_unlock( &mutex_ );
|
||||
|
||||
return tex;
|
||||
|
||||
}
|
||||
|
||||
std::string JNIHelper::ConvertString( const char* str,
|
||||
const char* encode )
|
||||
{
|
||||
if( activity_ == NULL )
|
||||
{
|
||||
LOGI( "JNIHelper has not been initialized. Call init() to initialize the helper" );
|
||||
return std::string( "" );
|
||||
}
|
||||
|
||||
JNIEnv *env;
|
||||
|
||||
pthread_mutex_lock( &mutex_ );
|
||||
activity_->vm->AttachCurrentThread( &env, NULL );
|
||||
|
||||
int32_t iLength = strlen( (const char*) str );
|
||||
|
||||
jbyteArray array = env->NewByteArray( iLength );
|
||||
env->SetByteArrayRegion( array, 0, iLength, (const signed char*) str );
|
||||
|
||||
jstring strEncode = env->NewStringUTF( encode );
|
||||
|
||||
jclass cls = env->FindClass( "java/lang/String" );
|
||||
jmethodID ctor = env->GetMethodID( cls, "<init>", "([BLjava/lang/String;)V" );
|
||||
jstring object = (jstring) env->NewObject( cls, ctor, array, strEncode );
|
||||
|
||||
const char *cparam = env->GetStringUTFChars( object, NULL );
|
||||
|
||||
std::string s = std::string( cparam );
|
||||
|
||||
env->ReleaseStringUTFChars( object, cparam );
|
||||
env->DeleteLocalRef( strEncode );
|
||||
env->DeleteLocalRef( object );
|
||||
activity_->vm->DetachCurrentThread();
|
||||
pthread_mutex_unlock( &mutex_ );
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//Audio helpers
|
||||
//---------------------------------------------------------------------------
|
||||
int32_t JNIHelper::GetNativeAudioBufferSize()
|
||||
{
|
||||
if( activity_ == NULL )
|
||||
{
|
||||
LOGI( "JNIHelper has not been initialized. Call init() to initialize the helper" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
JNIEnv *env;
|
||||
jmethodID mid;
|
||||
|
||||
pthread_mutex_lock( &mutex_ );
|
||||
activity_->vm->AttachCurrentThread( &env, NULL );
|
||||
|
||||
mid = env->GetMethodID( jni_helper_java_class_, "getNativeAudioBufferSize", "()I" );
|
||||
int32_t i = env->CallIntMethod( jni_helper_java_ref_, mid );
|
||||
activity_->vm->DetachCurrentThread();
|
||||
pthread_mutex_unlock( &mutex_ );
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
int32_t JNIHelper::GetNativeAudioSampleRate()
|
||||
{
|
||||
if( activity_ == NULL )
|
||||
{
|
||||
LOGI( "JNIHelper has not been initialized. Call init() to initialize the helper" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
JNIEnv *env;
|
||||
jmethodID mid;
|
||||
|
||||
pthread_mutex_lock( &mutex_ );
|
||||
activity_->vm->AttachCurrentThread( &env, NULL );
|
||||
|
||||
mid = env->GetMethodID( jni_helper_java_class_, "getNativeAudioSampleRate", "()I" );
|
||||
int32_t i = env->CallIntMethod( jni_helper_java_ref_, mid );
|
||||
activity_->vm->DetachCurrentThread();
|
||||
pthread_mutex_unlock( &mutex_ );
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//Misc implementations
|
||||
//---------------------------------------------------------------------------
|
||||
jclass JNIHelper::RetrieveClass( JNIEnv *jni,
|
||||
const char* class_name )
|
||||
{
|
||||
jclass activity_class = jni->FindClass( CLASS_NAME );
|
||||
jmethodID get_class_loader = jni->GetMethodID( activity_class, "getClassLoader",
|
||||
"()Ljava/lang/ClassLoader;" );
|
||||
jobject cls = jni->CallObjectMethod( activity_->clazz, get_class_loader );
|
||||
jclass class_loader = jni->FindClass( "java/lang/ClassLoader" );
|
||||
jmethodID find_class = jni->GetMethodID( class_loader, "loadClass",
|
||||
"(Ljava/lang/String;)Ljava/lang/Class;" );
|
||||
|
||||
jstring str_class_name = jni->NewStringUTF( class_name );
|
||||
jclass class_retrieved = (jclass) jni->CallObjectMethod( cls, find_class, str_class_name );
|
||||
jni->DeleteLocalRef( str_class_name );
|
||||
return class_retrieved;
|
||||
}
|
||||
|
||||
jstring JNIHelper::GetExternalFilesDirJString( JNIEnv *env )
|
||||
{
|
||||
if( activity_ == NULL )
|
||||
{
|
||||
LOGI( "JNIHelper has not been initialized. Call init() to initialize the helper" );
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Invoking getExternalFilesDir() java API
|
||||
jclass cls_Env = env->FindClass( CLASS_NAME );
|
||||
jmethodID mid = env->GetMethodID( cls_Env, "getExternalFilesDir",
|
||||
"(Ljava/lang/String;)Ljava/io/File;" );
|
||||
jobject obj_File = env->CallObjectMethod( activity_->clazz, mid, NULL );
|
||||
jclass cls_File = env->FindClass( "java/io/File" );
|
||||
jmethodID mid_getPath = env->GetMethodID( cls_File, "getPath", "()Ljava/lang/String;" );
|
||||
jstring obj_Path = (jstring) env->CallObjectMethod( obj_File, mid_getPath );
|
||||
|
||||
return obj_Path;
|
||||
}
|
||||
|
||||
} //namespace ndkHelper
|
||||
@@ -1,171 +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.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <jni.h>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
#include <android/log.h>
|
||||
#include <android_native_app_glue.h>
|
||||
|
||||
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, ndk_helper::JNIHelper::GetInstance()->GetAppName(), __VA_ARGS__))
|
||||
#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, ndk_helper::JNIHelper::GetInstance()->GetAppName(), __VA_ARGS__))
|
||||
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, ndk_helper::JNIHelper::GetInstance()->GetAppName(), __VA_ARGS__))
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
/******************************************************************
|
||||
* Helper functions for JNI calls
|
||||
* This class wraps JNI calls and provides handy interface calling commonly used features
|
||||
* in Java SDK.
|
||||
* Such as
|
||||
* - loading graphics files (e.g. PNG, JPG)
|
||||
* - character code conversion
|
||||
* - retrieving system properties which only supported in Java SDK
|
||||
*
|
||||
* NOTE: To use this class, add NDKHelper.java as a corresponding helpers in Java code
|
||||
*/
|
||||
class JNIHelper
|
||||
{
|
||||
private:
|
||||
std::string app_name_;
|
||||
|
||||
ANativeActivity* activity_;
|
||||
jobject jni_helper_java_ref_;
|
||||
jclass jni_helper_java_class_;
|
||||
|
||||
//mutex for synchronization
|
||||
//This class uses singleton pattern and can be invoked from multiple threads,
|
||||
//each methods locks the mutex for a thread safety
|
||||
mutable pthread_mutex_t mutex_;
|
||||
|
||||
jstring GetExternalFilesDirJString( JNIEnv *env );
|
||||
jclass RetrieveClass( JNIEnv *jni,
|
||||
const char* class_name );
|
||||
|
||||
JNIHelper();
|
||||
~JNIHelper();
|
||||
JNIHelper( const JNIHelper& rhs );
|
||||
JNIHelper& operator=( const JNIHelper& rhs );
|
||||
|
||||
public:
|
||||
/*
|
||||
* To load your own Java classes, JNIHelper requires to be initialized with a ANativeActivity handle.
|
||||
* This methods need to be called before any call to the helper class.
|
||||
* Static member of the class
|
||||
*
|
||||
* arguments:
|
||||
* in: activity, pointer to ANativeActivity. Used internally to set up JNI environment
|
||||
* in: helper_class_name, pointer to Java side helper class name. (e.g. "com/sample/helper/NDKHelper" in samples )
|
||||
*/
|
||||
static void Init( ANativeActivity* activity,
|
||||
const char* helper_class_name );
|
||||
|
||||
/*
|
||||
* Retrieve the singleton object of the helper.
|
||||
* Static member of the class
|
||||
|
||||
* Methods in the class are designed as thread safe.
|
||||
*/
|
||||
static JNIHelper* GetInstance();
|
||||
|
||||
/*
|
||||
* Read a file from a strorage.
|
||||
* First, the method tries to read the file from an external storage.
|
||||
* If it fails to read, it falls back to use assset manager and try to read the file from APK asset.
|
||||
*
|
||||
* arguments:
|
||||
* in: file_name, file name to read
|
||||
* out: buffer_ref, pointer to a vector buffer to read a file.
|
||||
* when the call succeeded, the buffer includes contents of specified file
|
||||
* when the call failed, contents of the buffer remains same
|
||||
* return:
|
||||
* true when file read succeeded
|
||||
* false when it failed to read the file
|
||||
*/
|
||||
bool ReadFile( const char* file_name,
|
||||
std::vector<uint8_t>* buffer_ref );
|
||||
|
||||
/*
|
||||
* Load and create OpenGL texture from given file name.
|
||||
* The method invokes BitmapFactory in Java so it can read jpeg/png formatted files
|
||||
*
|
||||
* The methods creates mip-map and set texture parameters like this,
|
||||
* glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );
|
||||
* glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
|
||||
* glGenerateMipmap( GL_TEXTURE_2D );
|
||||
*
|
||||
* arguments:
|
||||
* in: file_name, file name to read, PNG&JPG is supported
|
||||
* return:
|
||||
* OpenGL texture name when the call succeeded
|
||||
* When it failed to load the texture, it returns -1
|
||||
*/
|
||||
uint32_t LoadTexture( const char* file_name );
|
||||
|
||||
/*
|
||||
* Convert string from character code other than UTF-8
|
||||
*
|
||||
* arguments:
|
||||
* in: str, pointer to a string which is encoded other than UTF-8
|
||||
* in: encoding, pointer to a character encoding string.
|
||||
* The encoding string can be any valid java.nio.charset.Charset name
|
||||
* e.g. "UTF-16", "Shift_JIS"
|
||||
* return: converted input string as an UTF-8 std::string
|
||||
*/
|
||||
std::string ConvertString( const char* str,
|
||||
const char* encode );
|
||||
/*
|
||||
* Retrieve external file directory through JNI call
|
||||
*
|
||||
* return: std::string containing external file diretory
|
||||
*/
|
||||
std::string GetExternalFilesDir();
|
||||
|
||||
/*
|
||||
* Audio helper
|
||||
* Retrieves native audio buffer size which is required to achieve low latency audio
|
||||
*
|
||||
* return: Native audio buffer size which is a hint to achieve low latency audio
|
||||
* If the API is not supported (API level < 17), it returns 0
|
||||
*/
|
||||
int32_t GetNativeAudioBufferSize();
|
||||
|
||||
/*
|
||||
* Audio helper
|
||||
* Retrieves native audio sample rate which is required to achieve low latency audio
|
||||
*
|
||||
* return: Native audio sample rate which is a hint to achieve low latency audio
|
||||
*/
|
||||
int32_t GetNativeAudioSampleRate();
|
||||
|
||||
/*
|
||||
* Retrieves application bundle name
|
||||
*
|
||||
* return: pointer to an app name string
|
||||
*
|
||||
*/
|
||||
const char* GetAppName()
|
||||
{
|
||||
return app_name_.c_str();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} //namespace ndkHelper
|
||||
@@ -1,39 +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.
|
||||
*/
|
||||
|
||||
#ifndef _NDKSUPPORT_H
|
||||
#define _NDKSUPPORT_H
|
||||
|
||||
/******************************************************************
|
||||
* NDK support helpers
|
||||
* Utility module to provide misc functionalities that is used widely in native applications,
|
||||
* such as gesture detection, jni bridge, openGL context etc.
|
||||
*
|
||||
* The purpose of this module is,
|
||||
* - Provide best practices using NDK
|
||||
* - Provide handy utility functions for NDK development
|
||||
* - Make NDK samples more simpler and readable
|
||||
*/
|
||||
#include "gl3stub.h" //GLES3 stubs
|
||||
#include "GLContext.h" //EGL & OpenGL manager
|
||||
#include "shader.h" //Shader compiler support
|
||||
#include "vecmath.h" //Vector math support, C++ implementation n current version
|
||||
#include "tapCamera.h" //Tap/Pinch camera control
|
||||
#include "JNIHelper.h" //JNI support
|
||||
#include "gestureDetector.h" //Tap/Doubletap/Pinch detector
|
||||
#include "perfMonitor.h" //FPS counter
|
||||
#include "interpolator.h" //Interpolator
|
||||
#endif
|
||||
@@ -1,13 +0,0 @@
|
||||
Copyright (C) 2016 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.
|
||||
@@ -1,350 +0,0 @@
|
||||
/*
|
||||
* Copyright 2013 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include "gestureDetector.h"
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// gestureDetector.cpp
|
||||
//--------------------------------------------------------------------------------
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// includes
|
||||
//--------------------------------------------------------------------------------
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// GestureDetector
|
||||
//--------------------------------------------------------------------------------
|
||||
GestureDetector::GestureDetector()
|
||||
{
|
||||
dp_factor_ = 1.f;
|
||||
}
|
||||
|
||||
void GestureDetector::SetConfiguration( AConfiguration* config )
|
||||
{
|
||||
dp_factor_ = 160.f / AConfiguration_getDensity( config );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// TapDetector
|
||||
//--------------------------------------------------------------------------------
|
||||
GESTURE_STATE TapDetector::Detect( const AInputEvent* motion_event )
|
||||
{
|
||||
if( AMotionEvent_getPointerCount( motion_event ) > 1 )
|
||||
{
|
||||
//Only support single touch
|
||||
return false;
|
||||
}
|
||||
|
||||
int32_t action = AMotionEvent_getAction( motion_event );
|
||||
unsigned int flags = action & AMOTION_EVENT_ACTION_MASK;
|
||||
switch( flags )
|
||||
{
|
||||
case AMOTION_EVENT_ACTION_DOWN:
|
||||
down_pointer_id_ = AMotionEvent_getPointerId( motion_event, 0 );
|
||||
down_x_ = AMotionEvent_getX( motion_event, 0 );
|
||||
down_y_ = AMotionEvent_getY( motion_event, 0 );
|
||||
break;
|
||||
case AMOTION_EVENT_ACTION_UP:
|
||||
{
|
||||
int64_t eventTime = AMotionEvent_getEventTime( motion_event );
|
||||
int64_t downTime = AMotionEvent_getDownTime( motion_event );
|
||||
if( eventTime - downTime <= TAP_TIMEOUT )
|
||||
{
|
||||
if( down_pointer_id_ == AMotionEvent_getPointerId( motion_event, 0 ) )
|
||||
{
|
||||
float x = AMotionEvent_getX( motion_event, 0 ) - down_x_;
|
||||
float y = AMotionEvent_getY( motion_event, 0 ) - down_y_;
|
||||
if( x * x + y * y < TOUCH_SLOP * TOUCH_SLOP * dp_factor_ )
|
||||
{
|
||||
LOGI( "TapDetector: Tap detected" );
|
||||
return GESTURE_STATE_ACTION;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return GESTURE_STATE_NONE;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// DoubletapDetector
|
||||
//--------------------------------------------------------------------------------
|
||||
GESTURE_STATE DoubletapDetector::Detect( const AInputEvent* motion_event )
|
||||
{
|
||||
if( AMotionEvent_getPointerCount( motion_event ) > 1 )
|
||||
{
|
||||
//Only support single double tap
|
||||
return false;
|
||||
}
|
||||
|
||||
bool tap_detected = tap_detector_.Detect( motion_event );
|
||||
|
||||
int32_t action = AMotionEvent_getAction( motion_event );
|
||||
unsigned int flags = action & AMOTION_EVENT_ACTION_MASK;
|
||||
switch( flags )
|
||||
{
|
||||
case AMOTION_EVENT_ACTION_DOWN:
|
||||
{
|
||||
int64_t eventTime = AMotionEvent_getEventTime( motion_event );
|
||||
if( eventTime - last_tap_time_ <= DOUBLE_TAP_TIMEOUT )
|
||||
{
|
||||
float x = AMotionEvent_getX( motion_event, 0 ) - last_tap_x_;
|
||||
float y = AMotionEvent_getY( motion_event, 0 ) - last_tap_y_;
|
||||
if( x * x + y * y < DOUBLE_TAP_SLOP * DOUBLE_TAP_SLOP * dp_factor_ )
|
||||
{
|
||||
LOGI( "DoubletapDetector: Doubletap detected" );
|
||||
return GESTURE_STATE_ACTION;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case AMOTION_EVENT_ACTION_UP:
|
||||
if( tap_detected )
|
||||
{
|
||||
last_tap_time_ = AMotionEvent_getEventTime( motion_event );
|
||||
last_tap_x_ = AMotionEvent_getX( motion_event, 0 );
|
||||
last_tap_y_ = AMotionEvent_getY( motion_event, 0 );
|
||||
}
|
||||
break;
|
||||
}
|
||||
return GESTURE_STATE_NONE;
|
||||
}
|
||||
|
||||
void DoubletapDetector::SetConfiguration( AConfiguration* config )
|
||||
{
|
||||
dp_factor_ = 160.f / AConfiguration_getDensity( config );
|
||||
tap_detector_.SetConfiguration( config );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// PinchDetector
|
||||
//--------------------------------------------------------------------------------
|
||||
|
||||
int32_t PinchDetector::FindIndex( const AInputEvent* event, int32_t id )
|
||||
{
|
||||
int32_t count = AMotionEvent_getPointerCount( event );
|
||||
for( uint32_t i = 0; i < count; ++i )
|
||||
{
|
||||
if( id == AMotionEvent_getPointerId( event, i ) )
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
GESTURE_STATE PinchDetector::Detect( const AInputEvent* event )
|
||||
{
|
||||
GESTURE_STATE ret = GESTURE_STATE_NONE;
|
||||
int32_t action = AMotionEvent_getAction( event );
|
||||
uint32_t flags = action & AMOTION_EVENT_ACTION_MASK;
|
||||
event_ = event;
|
||||
|
||||
int32_t count = AMotionEvent_getPointerCount( event );
|
||||
switch( flags )
|
||||
{
|
||||
case AMOTION_EVENT_ACTION_DOWN:
|
||||
vec_pointers_.push_back( AMotionEvent_getPointerId( event, 0 ) );
|
||||
break;
|
||||
case AMOTION_EVENT_ACTION_POINTER_DOWN:
|
||||
{
|
||||
int32_t iIndex = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK)
|
||||
>> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
|
||||
vec_pointers_.push_back( AMotionEvent_getPointerId( event, iIndex ) );
|
||||
if( count == 2 )
|
||||
{
|
||||
//Start new pinch
|
||||
ret = GESTURE_STATE_START;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case AMOTION_EVENT_ACTION_UP:
|
||||
vec_pointers_.pop_back();
|
||||
break;
|
||||
case AMOTION_EVENT_ACTION_POINTER_UP:
|
||||
{
|
||||
int32_t index = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK)
|
||||
>> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
|
||||
int32_t released_pointer_id = AMotionEvent_getPointerId( event, index );
|
||||
|
||||
std::vector<int32_t>::iterator it = vec_pointers_.begin();
|
||||
std::vector<int32_t>::iterator it_end = vec_pointers_.end();
|
||||
int32_t i = 0;
|
||||
for( ; it != it_end; ++it, ++i )
|
||||
{
|
||||
if( *it == released_pointer_id )
|
||||
{
|
||||
vec_pointers_.erase( it );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if( i <= 1 )
|
||||
{
|
||||
//Reset pinch or drag
|
||||
if( count != 2 )
|
||||
{
|
||||
//Start new pinch
|
||||
ret = GESTURE_STATE_START | GESTURE_STATE_END;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case AMOTION_EVENT_ACTION_MOVE:
|
||||
switch( count )
|
||||
{
|
||||
case 1:
|
||||
break;
|
||||
default:
|
||||
//Multi touch
|
||||
ret = GESTURE_STATE_MOVE;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case AMOTION_EVENT_ACTION_CANCEL:
|
||||
break;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool PinchDetector::GetPointers( Vec2& v1, Vec2& v2 )
|
||||
{
|
||||
if( vec_pointers_.size() < 2 )
|
||||
return false;
|
||||
|
||||
int32_t index = FindIndex( event_, vec_pointers_[0] );
|
||||
if( index == -1 )
|
||||
return false;
|
||||
|
||||
float x = AMotionEvent_getX( event_, index );
|
||||
float y = AMotionEvent_getY( event_, index );
|
||||
|
||||
index = FindIndex( event_, vec_pointers_[1] );
|
||||
if( index == -1 )
|
||||
return false;
|
||||
|
||||
float x2 = AMotionEvent_getX( event_, index );
|
||||
float y2 = AMotionEvent_getY( event_, index );
|
||||
|
||||
v1 = Vec2( x, y );
|
||||
v2 = Vec2( x2, y2 );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// DragDetector
|
||||
//--------------------------------------------------------------------------------
|
||||
|
||||
int32_t DragDetector::FindIndex( const AInputEvent* event, int32_t id )
|
||||
{
|
||||
int32_t count = AMotionEvent_getPointerCount( event );
|
||||
for( uint32_t i = 0; i < count; ++i )
|
||||
{
|
||||
if( id == AMotionEvent_getPointerId( event, i ) )
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
GESTURE_STATE DragDetector::Detect( const AInputEvent* event )
|
||||
{
|
||||
GESTURE_STATE ret = GESTURE_STATE_NONE;
|
||||
int32_t action = AMotionEvent_getAction( event );
|
||||
int32_t index = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK)
|
||||
>> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
|
||||
uint32_t flags = action & AMOTION_EVENT_ACTION_MASK;
|
||||
event_ = event;
|
||||
|
||||
int32_t count = AMotionEvent_getPointerCount( event );
|
||||
switch( flags )
|
||||
{
|
||||
case AMOTION_EVENT_ACTION_DOWN:
|
||||
vec_pointers_.push_back( AMotionEvent_getPointerId( event, 0 ) );
|
||||
ret = GESTURE_STATE_START;
|
||||
break;
|
||||
case AMOTION_EVENT_ACTION_POINTER_DOWN:
|
||||
vec_pointers_.push_back( AMotionEvent_getPointerId( event, index ) );
|
||||
break;
|
||||
case AMOTION_EVENT_ACTION_UP:
|
||||
vec_pointers_.pop_back();
|
||||
ret = GESTURE_STATE_END;
|
||||
break;
|
||||
case AMOTION_EVENT_ACTION_POINTER_UP:
|
||||
{
|
||||
int32_t released_pointer_id = AMotionEvent_getPointerId( event, index );
|
||||
|
||||
std::vector<int32_t>::iterator it = vec_pointers_.begin();
|
||||
std::vector<int32_t>::iterator it_end = vec_pointers_.end();
|
||||
int32_t i = 0;
|
||||
for( ; it != it_end; ++it, ++i )
|
||||
{
|
||||
if( *it == released_pointer_id )
|
||||
{
|
||||
vec_pointers_.erase( it );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if( i <= 1 )
|
||||
{
|
||||
//Reset pinch or drag
|
||||
if( count == 2 )
|
||||
{
|
||||
ret = GESTURE_STATE_START;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case AMOTION_EVENT_ACTION_MOVE:
|
||||
switch( count )
|
||||
{
|
||||
case 1:
|
||||
//Drag
|
||||
ret = GESTURE_STATE_MOVE;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case AMOTION_EVENT_ACTION_CANCEL:
|
||||
break;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool DragDetector::GetPointer( Vec2& v )
|
||||
{
|
||||
if( vec_pointers_.size() < 1 )
|
||||
return false;
|
||||
|
||||
int32_t iIndex = FindIndex( event_, vec_pointers_[0] );
|
||||
if( iIndex == -1 )
|
||||
return false;
|
||||
|
||||
float x = AMotionEvent_getX( event_, iIndex );
|
||||
float y = AMotionEvent_getY( event_, iIndex );
|
||||
|
||||
v = Vec2( x, y );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
} //namespace ndkHelper
|
||||
|
||||
@@ -1,166 +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 <vector>
|
||||
|
||||
#include <android/sensor.h>
|
||||
#include <android/log.h>
|
||||
#include <android_native_app_glue.h>
|
||||
#include <android/native_window_jni.h>
|
||||
#include "JNIHelper.h"
|
||||
#include "vecmath.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
//--------------------------------------------------------------------------------
|
||||
// Constants
|
||||
//--------------------------------------------------------------------------------
|
||||
const int32_t DOUBLE_TAP_TIMEOUT = 300 * 1000000;
|
||||
const int32_t TAP_TIMEOUT = 180 * 1000000;
|
||||
const int32_t DOUBLE_TAP_SLOP = 100;
|
||||
const int32_t TOUCH_SLOP = 8;
|
||||
|
||||
enum
|
||||
{
|
||||
GESTURE_STATE_NONE = 0,
|
||||
GESTURE_STATE_START = 1,
|
||||
GESTURE_STATE_MOVE = 2,
|
||||
GESTURE_STATE_END = 4,
|
||||
GESTURE_STATE_ACTION = (GESTURE_STATE_START | GESTURE_STATE_END),
|
||||
};
|
||||
typedef int32_t GESTURE_STATE;
|
||||
|
||||
/******************************************************************
|
||||
* Base class of Gesture Detectors
|
||||
* GestureDetectors handles input events and detect gestures
|
||||
* Note that different detectors may detect gestures with an event at
|
||||
* same time. The caller needs to manage gesture priority accordingly
|
||||
*
|
||||
*/
|
||||
class GestureDetector
|
||||
{
|
||||
protected:
|
||||
float dp_factor_;
|
||||
public:
|
||||
GestureDetector();
|
||||
virtual ~GestureDetector()
|
||||
{
|
||||
}
|
||||
virtual void SetConfiguration( AConfiguration* config );
|
||||
|
||||
virtual GESTURE_STATE Detect( const AInputEvent* motion_event ) = 0;
|
||||
};
|
||||
|
||||
/******************************************************************
|
||||
* Tap gesture detector
|
||||
* Returns GESTURE_STATE_ACTION when a tap gesture is detected
|
||||
*
|
||||
*/
|
||||
class TapDetector: public GestureDetector
|
||||
{
|
||||
private:
|
||||
int32_t down_pointer_id_;
|
||||
float down_x_;
|
||||
float down_y_;
|
||||
public:
|
||||
TapDetector()
|
||||
{
|
||||
}
|
||||
virtual ~TapDetector()
|
||||
{
|
||||
}
|
||||
virtual GESTURE_STATE Detect( const AInputEvent* motion_event );
|
||||
};
|
||||
|
||||
/******************************************************************
|
||||
* Pinch gesture detector
|
||||
* Returns GESTURE_STATE_ACTION when a double-tap gesture is detected
|
||||
*
|
||||
*/
|
||||
class DoubletapDetector: public GestureDetector
|
||||
{
|
||||
private:
|
||||
TapDetector tap_detector_;
|
||||
int64_t last_tap_time_;
|
||||
float last_tap_x_;
|
||||
float last_tap_y_;
|
||||
|
||||
public:
|
||||
DoubletapDetector()
|
||||
{
|
||||
}
|
||||
virtual ~DoubletapDetector()
|
||||
{
|
||||
}
|
||||
virtual GESTURE_STATE Detect( const AInputEvent* motion_event );
|
||||
virtual void SetConfiguration( AConfiguration* config );
|
||||
};
|
||||
|
||||
/******************************************************************
|
||||
* Double gesture detector
|
||||
* Returns pinch gesture state when a pinch gesture is detected
|
||||
* The class handles multiple touches more than 2
|
||||
* When the finger 1,2,3 are tapped and then finger 1 is released,
|
||||
* the detector start new pinch gesture with finger 2 & 3.
|
||||
*/
|
||||
class PinchDetector: public GestureDetector
|
||||
{
|
||||
private:
|
||||
int32_t FindIndex( const AInputEvent* event, int32_t id );
|
||||
const AInputEvent* event_;
|
||||
std::vector<int32_t> vec_pointers_;
|
||||
|
||||
public:
|
||||
PinchDetector()
|
||||
{
|
||||
}
|
||||
virtual ~PinchDetector()
|
||||
{
|
||||
}
|
||||
virtual GESTURE_STATE Detect( const AInputEvent* event );
|
||||
bool GetPointers( Vec2& v1, Vec2& v2 );
|
||||
};
|
||||
|
||||
/******************************************************************
|
||||
* Drag gesture detector
|
||||
* Returns drag gesture state when a drag-tap gesture is detected
|
||||
*
|
||||
*/
|
||||
class DragDetector: public GestureDetector
|
||||
{
|
||||
private:
|
||||
int32_t FindIndex( const AInputEvent* event, int32_t id );
|
||||
const AInputEvent* event_;
|
||||
std::vector<int32_t> vec_pointers_;
|
||||
public:
|
||||
DragDetector()
|
||||
{
|
||||
}
|
||||
virtual ~DragDetector()
|
||||
{
|
||||
}
|
||||
virtual GESTURE_STATE Detect( const AInputEvent* event );
|
||||
bool GetPointer( Vec2& v );
|
||||
};
|
||||
|
||||
} //namespace ndkHelper
|
||||
#endif /* GESTUREDETECTOR_H_ */
|
||||
@@ -1,512 +0,0 @@
|
||||
/*
|
||||
* Copyright 2013 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include <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 );
|
||||
@@ -1,504 +0,0 @@
|
||||
#ifndef __gl3_h_
|
||||
#define __gl3_h_
|
||||
|
||||
/*
|
||||
* stub gl3.h for dynamic loading, based on:
|
||||
* gl3.h last updated on $Date: 2013-02-12 14:37:24 -0800 (Tue, 12 Feb 2013) $
|
||||
*
|
||||
* Changes:
|
||||
* - Added #include <GLES2/gl2.h>
|
||||
* - Removed duplicate OpenGL ES 2.0 declarations
|
||||
* - Converted OpenGL ES 3.0 function prototypes to function pointer
|
||||
* declarations
|
||||
* - Added gl3stubInit() declaration
|
||||
*/
|
||||
|
||||
#include <GLES2/gl2.h>
|
||||
#include <android/api-level.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/*
|
||||
** Copyright (c) 2007-2013 The Khronos Group Inc.
|
||||
**
|
||||
** Permission is hereby granted, free of charge, to any person obtaining a
|
||||
** copy of this software and/or associated documentation files (the
|
||||
** "Materials"), to deal in the Materials without restriction, including
|
||||
** without limitation the rights to use, copy, modify, merge, publish,
|
||||
** distribute, sublicense, and/or sell copies of the Materials, and to
|
||||
** permit persons to whom the Materials are furnished to do so, subject to
|
||||
** the following conditions:
|
||||
**
|
||||
** The above copyright notice and this permission notice shall be included
|
||||
** in all copies or substantial portions of the Materials.
|
||||
**
|
||||
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This files is for apps that want to use ES3 if present,
|
||||
* but continue to work on pre-API-18 devices. They can't just link to -lGLESv3 since
|
||||
* that library doesn't exist on pre-API-18 devices.
|
||||
* The function dynamically check if OpenGLES3.0 APIs are present and fill in if there are.
|
||||
* Also the header defines some extra variables for OpenGLES3.0.
|
||||
*
|
||||
*/
|
||||
|
||||
/* Call this function before calling any OpenGL ES 3.0 functions. It will
|
||||
* return GL_TRUE if the OpenGL ES 3.0 was successfully initialized, GL_FALSE
|
||||
* otherwise. */
|
||||
GLboolean gl3stubInit();
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Data type definitions
|
||||
*-----------------------------------------------------------------------*/
|
||||
|
||||
/* OpenGL ES 3.0 */
|
||||
|
||||
typedef unsigned short GLhalf;
|
||||
#if __ANDROID_API__ <= 19
|
||||
typedef khronos_int64_t GLint64;
|
||||
typedef khronos_uint64_t GLuint64;
|
||||
typedef struct __GLsync *GLsync;
|
||||
#endif
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Token definitions
|
||||
*-----------------------------------------------------------------------*/
|
||||
|
||||
/* OpenGL ES core versions */
|
||||
#define GL_ES_VERSION_3_0 1
|
||||
|
||||
/* OpenGL ES 3.0 */
|
||||
|
||||
#define GL_READ_BUFFER 0x0C02
|
||||
#define GL_UNPACK_ROW_LENGTH 0x0CF2
|
||||
#define GL_UNPACK_SKIP_ROWS 0x0CF3
|
||||
#define GL_UNPACK_SKIP_PIXELS 0x0CF4
|
||||
#define GL_PACK_ROW_LENGTH 0x0D02
|
||||
#define GL_PACK_SKIP_ROWS 0x0D03
|
||||
#define GL_PACK_SKIP_PIXELS 0x0D04
|
||||
#define GL_COLOR 0x1800
|
||||
#define GL_DEPTH 0x1801
|
||||
#define GL_STENCIL 0x1802
|
||||
#define GL_RED 0x1903
|
||||
#define GL_RGB8 0x8051
|
||||
#define GL_RGBA8 0x8058
|
||||
#define GL_RGB10_A2 0x8059
|
||||
#define GL_TEXTURE_BINDING_3D 0x806A
|
||||
#define GL_UNPACK_SKIP_IMAGES 0x806D
|
||||
#define GL_UNPACK_IMAGE_HEIGHT 0x806E
|
||||
#define GL_TEXTURE_3D 0x806F
|
||||
#define GL_TEXTURE_WRAP_R 0x8072
|
||||
#define GL_MAX_3D_TEXTURE_SIZE 0x8073
|
||||
#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
|
||||
#define GL_MAX_ELEMENTS_VERTICES 0x80E8
|
||||
#define GL_MAX_ELEMENTS_INDICES 0x80E9
|
||||
#define GL_TEXTURE_MIN_LOD 0x813A
|
||||
#define GL_TEXTURE_MAX_LOD 0x813B
|
||||
#define GL_TEXTURE_BASE_LEVEL 0x813C
|
||||
#define GL_TEXTURE_MAX_LEVEL 0x813D
|
||||
#define GL_MIN 0x8007
|
||||
#define GL_MAX 0x8008
|
||||
#define GL_DEPTH_COMPONENT24 0x81A6
|
||||
#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
|
||||
#define GL_TEXTURE_COMPARE_MODE 0x884C
|
||||
#define GL_TEXTURE_COMPARE_FUNC 0x884D
|
||||
#define GL_CURRENT_QUERY 0x8865
|
||||
#define GL_QUERY_RESULT 0x8866
|
||||
#define GL_QUERY_RESULT_AVAILABLE 0x8867
|
||||
#define GL_BUFFER_MAPPED 0x88BC
|
||||
#define GL_BUFFER_MAP_POINTER 0x88BD
|
||||
#define GL_STREAM_READ 0x88E1
|
||||
#define GL_STREAM_COPY 0x88E2
|
||||
#define GL_STATIC_READ 0x88E5
|
||||
#define GL_STATIC_COPY 0x88E6
|
||||
#define GL_DYNAMIC_READ 0x88E9
|
||||
#define GL_DYNAMIC_COPY 0x88EA
|
||||
#define GL_MAX_DRAW_BUFFERS 0x8824
|
||||
#define GL_DRAW_BUFFER0 0x8825
|
||||
#define GL_DRAW_BUFFER1 0x8826
|
||||
#define GL_DRAW_BUFFER2 0x8827
|
||||
#define GL_DRAW_BUFFER3 0x8828
|
||||
#define GL_DRAW_BUFFER4 0x8829
|
||||
#define GL_DRAW_BUFFER5 0x882A
|
||||
#define GL_DRAW_BUFFER6 0x882B
|
||||
#define GL_DRAW_BUFFER7 0x882C
|
||||
#define GL_DRAW_BUFFER8 0x882D
|
||||
#define GL_DRAW_BUFFER9 0x882E
|
||||
#define GL_DRAW_BUFFER10 0x882F
|
||||
#define GL_DRAW_BUFFER11 0x8830
|
||||
#define GL_DRAW_BUFFER12 0x8831
|
||||
#define GL_DRAW_BUFFER13 0x8832
|
||||
#define GL_DRAW_BUFFER14 0x8833
|
||||
#define GL_DRAW_BUFFER15 0x8834
|
||||
#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
|
||||
#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
|
||||
#define GL_SAMPLER_3D 0x8B5F
|
||||
#define GL_SAMPLER_2D_SHADOW 0x8B62
|
||||
#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
|
||||
#define GL_PIXEL_PACK_BUFFER 0x88EB
|
||||
#define GL_PIXEL_UNPACK_BUFFER 0x88EC
|
||||
#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
|
||||
#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
|
||||
#define GL_FLOAT_MAT2x3 0x8B65
|
||||
#define GL_FLOAT_MAT2x4 0x8B66
|
||||
#define GL_FLOAT_MAT3x2 0x8B67
|
||||
#define GL_FLOAT_MAT3x4 0x8B68
|
||||
#define GL_FLOAT_MAT4x2 0x8B69
|
||||
#define GL_FLOAT_MAT4x3 0x8B6A
|
||||
#define GL_SRGB 0x8C40
|
||||
#define GL_SRGB8 0x8C41
|
||||
#define GL_SRGB8_ALPHA8 0x8C43
|
||||
#define GL_COMPARE_REF_TO_TEXTURE 0x884E
|
||||
#define GL_MAJOR_VERSION 0x821B
|
||||
#define GL_MINOR_VERSION 0x821C
|
||||
#define GL_NUM_EXTENSIONS 0x821D
|
||||
#define GL_RGBA32F 0x8814
|
||||
#define GL_RGB32F 0x8815
|
||||
#define GL_RGBA16F 0x881A
|
||||
#define GL_RGB16F 0x881B
|
||||
#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD
|
||||
#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF
|
||||
#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904
|
||||
#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905
|
||||
#define GL_MAX_VARYING_COMPONENTS 0x8B4B
|
||||
#define GL_TEXTURE_2D_ARRAY 0x8C1A
|
||||
#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D
|
||||
#define GL_R11F_G11F_B10F 0x8C3A
|
||||
#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B
|
||||
#define GL_RGB9_E5 0x8C3D
|
||||
#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E
|
||||
#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
|
||||
#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
|
||||
#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
|
||||
#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83
|
||||
#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
|
||||
#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
|
||||
#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
|
||||
#define GL_RASTERIZER_DISCARD 0x8C89
|
||||
#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
|
||||
#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
|
||||
#define GL_INTERLEAVED_ATTRIBS 0x8C8C
|
||||
#define GL_SEPARATE_ATTRIBS 0x8C8D
|
||||
#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E
|
||||
#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
|
||||
#define GL_RGBA32UI 0x8D70
|
||||
#define GL_RGB32UI 0x8D71
|
||||
#define GL_RGBA16UI 0x8D76
|
||||
#define GL_RGB16UI 0x8D77
|
||||
#define GL_RGBA8UI 0x8D7C
|
||||
#define GL_RGB8UI 0x8D7D
|
||||
#define GL_RGBA32I 0x8D82
|
||||
#define GL_RGB32I 0x8D83
|
||||
#define GL_RGBA16I 0x8D88
|
||||
#define GL_RGB16I 0x8D89
|
||||
#define GL_RGBA8I 0x8D8E
|
||||
#define GL_RGB8I 0x8D8F
|
||||
#define GL_RED_INTEGER 0x8D94
|
||||
#define GL_RGB_INTEGER 0x8D98
|
||||
#define GL_RGBA_INTEGER 0x8D99
|
||||
#define GL_SAMPLER_2D_ARRAY 0x8DC1
|
||||
#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4
|
||||
#define GL_SAMPLER_CUBE_SHADOW 0x8DC5
|
||||
#define GL_UNSIGNED_INT_VEC2 0x8DC6
|
||||
#define GL_UNSIGNED_INT_VEC3 0x8DC7
|
||||
#define GL_UNSIGNED_INT_VEC4 0x8DC8
|
||||
#define GL_INT_SAMPLER_2D 0x8DCA
|
||||
#define GL_INT_SAMPLER_3D 0x8DCB
|
||||
#define GL_INT_SAMPLER_CUBE 0x8DCC
|
||||
#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF
|
||||
#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2
|
||||
#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3
|
||||
#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4
|
||||
#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7
|
||||
#define GL_BUFFER_ACCESS_FLAGS 0x911F
|
||||
#define GL_BUFFER_MAP_LENGTH 0x9120
|
||||
#define GL_BUFFER_MAP_OFFSET 0x9121
|
||||
#define GL_DEPTH_COMPONENT32F 0x8CAC
|
||||
#define GL_DEPTH32F_STENCIL8 0x8CAD
|
||||
#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
|
||||
#define GL_FRAMEBUFFER_DEFAULT 0x8218
|
||||
#define GL_FRAMEBUFFER_UNDEFINED 0x8219
|
||||
#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
|
||||
#define GL_DEPTH_STENCIL 0x84F9
|
||||
#define GL_UNSIGNED_INT_24_8 0x84FA
|
||||
#define GL_DEPTH24_STENCIL8 0x88F0
|
||||
#define GL_UNSIGNED_NORMALIZED 0x8C17
|
||||
#define GL_DRAW_FRAMEBUFFER_BINDING GL_FRAMEBUFFER_BINDING
|
||||
#define GL_READ_FRAMEBUFFER 0x8CA8
|
||||
#define GL_DRAW_FRAMEBUFFER 0x8CA9
|
||||
#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA
|
||||
#define GL_RENDERBUFFER_SAMPLES 0x8CAB
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
|
||||
#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
|
||||
#define GL_COLOR_ATTACHMENT1 0x8CE1
|
||||
#define GL_COLOR_ATTACHMENT2 0x8CE2
|
||||
#define GL_COLOR_ATTACHMENT3 0x8CE3
|
||||
#define GL_COLOR_ATTACHMENT4 0x8CE4
|
||||
#define GL_COLOR_ATTACHMENT5 0x8CE5
|
||||
#define GL_COLOR_ATTACHMENT6 0x8CE6
|
||||
#define GL_COLOR_ATTACHMENT7 0x8CE7
|
||||
#define GL_COLOR_ATTACHMENT8 0x8CE8
|
||||
#define GL_COLOR_ATTACHMENT9 0x8CE9
|
||||
#define GL_COLOR_ATTACHMENT10 0x8CEA
|
||||
#define GL_COLOR_ATTACHMENT11 0x8CEB
|
||||
#define GL_COLOR_ATTACHMENT12 0x8CEC
|
||||
#define GL_COLOR_ATTACHMENT13 0x8CED
|
||||
#define GL_COLOR_ATTACHMENT14 0x8CEE
|
||||
#define GL_COLOR_ATTACHMENT15 0x8CEF
|
||||
#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
|
||||
#define GL_MAX_SAMPLES 0x8D57
|
||||
#define GL_HALF_FLOAT 0x140B
|
||||
#define GL_MAP_READ_BIT 0x0001
|
||||
#define GL_MAP_WRITE_BIT 0x0002
|
||||
#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
|
||||
#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
|
||||
#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
|
||||
#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
|
||||
#define GL_RG 0x8227
|
||||
#define GL_RG_INTEGER 0x8228
|
||||
#define GL_R8 0x8229
|
||||
#define GL_RG8 0x822B
|
||||
#define GL_R16F 0x822D
|
||||
#define GL_R32F 0x822E
|
||||
#define GL_RG16F 0x822F
|
||||
#define GL_RG32F 0x8230
|
||||
#define GL_R8I 0x8231
|
||||
#define GL_R8UI 0x8232
|
||||
#define GL_R16I 0x8233
|
||||
#define GL_R16UI 0x8234
|
||||
#define GL_R32I 0x8235
|
||||
#define GL_R32UI 0x8236
|
||||
#define GL_RG8I 0x8237
|
||||
#define GL_RG8UI 0x8238
|
||||
#define GL_RG16I 0x8239
|
||||
#define GL_RG16UI 0x823A
|
||||
#define GL_RG32I 0x823B
|
||||
#define GL_RG32UI 0x823C
|
||||
#define GL_VERTEX_ARRAY_BINDING 0x85B5
|
||||
#define GL_R8_SNORM 0x8F94
|
||||
#define GL_RG8_SNORM 0x8F95
|
||||
#define GL_RGB8_SNORM 0x8F96
|
||||
#define GL_RGBA8_SNORM 0x8F97
|
||||
#define GL_SIGNED_NORMALIZED 0x8F9C
|
||||
#define GL_PRIMITIVE_RESTART_FIXED_INDEX 0x8D69
|
||||
#define GL_COPY_READ_BUFFER 0x8F36
|
||||
#define GL_COPY_WRITE_BUFFER 0x8F37
|
||||
#define GL_COPY_READ_BUFFER_BINDING GL_COPY_READ_BUFFER
|
||||
#define GL_COPY_WRITE_BUFFER_BINDING GL_COPY_WRITE_BUFFER
|
||||
#define GL_UNIFORM_BUFFER 0x8A11
|
||||
#define GL_UNIFORM_BUFFER_BINDING 0x8A28
|
||||
#define GL_UNIFORM_BUFFER_START 0x8A29
|
||||
#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
|
||||
#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
|
||||
#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
|
||||
#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
|
||||
#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
|
||||
#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
|
||||
#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
|
||||
#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
|
||||
#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
|
||||
#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
|
||||
#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
|
||||
#define GL_UNIFORM_TYPE 0x8A37
|
||||
#define GL_UNIFORM_SIZE 0x8A38
|
||||
#define GL_UNIFORM_NAME_LENGTH 0x8A39
|
||||
#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
|
||||
#define GL_UNIFORM_OFFSET 0x8A3B
|
||||
#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
|
||||
#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
|
||||
#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
|
||||
#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
|
||||
#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
|
||||
#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
|
||||
#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
|
||||
#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
|
||||
#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
|
||||
#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
|
||||
#define GL_INVALID_INDEX 0xFFFFFFFFu
|
||||
#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
|
||||
#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
|
||||
#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
|
||||
#define GL_OBJECT_TYPE 0x9112
|
||||
#define GL_SYNC_CONDITION 0x9113
|
||||
#define GL_SYNC_STATUS 0x9114
|
||||
#define GL_SYNC_FLAGS 0x9115
|
||||
#define GL_SYNC_FENCE 0x9116
|
||||
#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
|
||||
#define GL_UNSIGNALED 0x9118
|
||||
#define GL_SIGNALED 0x9119
|
||||
#define GL_ALREADY_SIGNALED 0x911A
|
||||
#define GL_TIMEOUT_EXPIRED 0x911B
|
||||
#define GL_CONDITION_SATISFIED 0x911C
|
||||
#define GL_WAIT_FAILED 0x911D
|
||||
#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
|
||||
#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFFull
|
||||
#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE
|
||||
#define GL_ANY_SAMPLES_PASSED 0x8C2F
|
||||
#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE 0x8D6A
|
||||
#define GL_SAMPLER_BINDING 0x8919
|
||||
#define GL_RGB10_A2UI 0x906F
|
||||
#define GL_TEXTURE_SWIZZLE_R 0x8E42
|
||||
#define GL_TEXTURE_SWIZZLE_G 0x8E43
|
||||
#define GL_TEXTURE_SWIZZLE_B 0x8E44
|
||||
#define GL_TEXTURE_SWIZZLE_A 0x8E45
|
||||
#define GL_GREEN 0x1904
|
||||
#define GL_BLUE 0x1905
|
||||
#define GL_INT_2_10_10_10_REV 0x8D9F
|
||||
#define GL_TRANSFORM_FEEDBACK 0x8E22
|
||||
#define GL_TRANSFORM_FEEDBACK_PAUSED 0x8E23
|
||||
#define GL_TRANSFORM_FEEDBACK_ACTIVE 0x8E24
|
||||
#define GL_TRANSFORM_FEEDBACK_BINDING 0x8E25
|
||||
#define GL_PROGRAM_BINARY_RETRIEVABLE_HINT 0x8257
|
||||
#define GL_PROGRAM_BINARY_LENGTH 0x8741
|
||||
#define GL_NUM_PROGRAM_BINARY_FORMATS 0x87FE
|
||||
#define GL_PROGRAM_BINARY_FORMATS 0x87FF
|
||||
#define GL_COMPRESSED_R11_EAC 0x9270
|
||||
#define GL_COMPRESSED_SIGNED_R11_EAC 0x9271
|
||||
#define GL_COMPRESSED_RG11_EAC 0x9272
|
||||
#define GL_COMPRESSED_SIGNED_RG11_EAC 0x9273
|
||||
#define GL_COMPRESSED_RGB8_ETC2 0x9274
|
||||
#define GL_COMPRESSED_SRGB8_ETC2 0x9275
|
||||
#define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276
|
||||
#define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277
|
||||
#define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278
|
||||
#define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279
|
||||
#define GL_TEXTURE_IMMUTABLE_FORMAT 0x912F
|
||||
#define GL_MAX_ELEMENT_INDEX 0x8D6B
|
||||
#define GL_NUM_SAMPLE_COUNTS 0x9380
|
||||
#define GL_TEXTURE_IMMUTABLE_LEVELS 0x82DF
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Entrypoint definitions
|
||||
*-----------------------------------------------------------------------*/
|
||||
|
||||
/* OpenGL ES 3.0 */
|
||||
|
||||
extern GL_APICALL void (* GL_APIENTRY glReadBuffer) (GLenum mode);
|
||||
extern GL_APICALL void (* GL_APIENTRY glDrawRangeElements) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices);
|
||||
extern GL_APICALL void (* GL_APIENTRY glTexImage3D) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
|
||||
extern GL_APICALL void (* GL_APIENTRY glTexSubImage3D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels);
|
||||
extern GL_APICALL void (* GL_APIENTRY glCopyTexSubImage3D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
|
||||
extern GL_APICALL void (* GL_APIENTRY glCompressedTexImage3D) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data);
|
||||
extern GL_APICALL void (* GL_APIENTRY glCompressedTexSubImage3D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGenQueries) (GLsizei n, GLuint* ids);
|
||||
extern GL_APICALL void (* GL_APIENTRY glDeleteQueries) (GLsizei n, const GLuint* ids);
|
||||
extern GL_APICALL GLboolean (* GL_APIENTRY glIsQuery) (GLuint id);
|
||||
extern GL_APICALL void (* GL_APIENTRY glBeginQuery) (GLenum target, GLuint id);
|
||||
extern GL_APICALL void (* GL_APIENTRY glEndQuery) (GLenum target);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetQueryiv) (GLenum target, GLenum pname, GLint* params);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetQueryObjectuiv) (GLuint id, GLenum pname, GLuint* params);
|
||||
extern GL_APICALL GLboolean (* GL_APIENTRY glUnmapBuffer) (GLenum target);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetBufferPointerv) (GLenum target, GLenum pname, GLvoid** params);
|
||||
extern GL_APICALL void (* GL_APIENTRY glDrawBuffers) (GLsizei n, const GLenum* bufs);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniformMatrix2x3fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniformMatrix3x2fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniformMatrix2x4fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniformMatrix4x2fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniformMatrix3x4fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniformMatrix4x3fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glBlitFramebuffer) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
|
||||
extern GL_APICALL void (* GL_APIENTRY glRenderbufferStorageMultisample) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
|
||||
extern GL_APICALL void (* GL_APIENTRY glFramebufferTextureLayer) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
|
||||
extern GL_APICALL GLvoid* (* GL_APIENTRY glMapBufferRange) (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
|
||||
extern GL_APICALL void (* GL_APIENTRY glFlushMappedBufferRange) (GLenum target, GLintptr offset, GLsizeiptr length);
|
||||
extern GL_APICALL void (* GL_APIENTRY glBindVertexArray) (GLuint array);
|
||||
extern GL_APICALL void (* GL_APIENTRY glDeleteVertexArrays) (GLsizei n, const GLuint* arrays);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGenVertexArrays) (GLsizei n, GLuint* arrays);
|
||||
extern GL_APICALL GLboolean (* GL_APIENTRY glIsVertexArray) (GLuint array);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetIntegeri_v) (GLenum target, GLuint index, GLint* data);
|
||||
extern GL_APICALL void (* GL_APIENTRY glBeginTransformFeedback) (GLenum primitiveMode);
|
||||
extern GL_APICALL void (* GL_APIENTRY glEndTransformFeedback) (void);
|
||||
extern GL_APICALL void (* GL_APIENTRY glBindBufferRange) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
|
||||
extern GL_APICALL void (* GL_APIENTRY glBindBufferBase) (GLenum target, GLuint index, GLuint buffer);
|
||||
extern GL_APICALL void (* GL_APIENTRY glTransformFeedbackVaryings) (GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetTransformFeedbackVarying) (GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name);
|
||||
extern GL_APICALL void (* GL_APIENTRY glVertexAttribIPointer) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetVertexAttribIiv) (GLuint index, GLenum pname, GLint* params);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetVertexAttribIuiv) (GLuint index, GLenum pname, GLuint* params);
|
||||
extern GL_APICALL void (* GL_APIENTRY glVertexAttribI4i) (GLuint index, GLint x, GLint y, GLint z, GLint w);
|
||||
extern GL_APICALL void (* GL_APIENTRY glVertexAttribI4ui) (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
|
||||
extern GL_APICALL void (* GL_APIENTRY glVertexAttribI4iv) (GLuint index, const GLint* v);
|
||||
extern GL_APICALL void (* GL_APIENTRY glVertexAttribI4uiv) (GLuint index, const GLuint* v);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetUniformuiv) (GLuint program, GLint location, GLuint* params);
|
||||
extern GL_APICALL GLint (* GL_APIENTRY glGetFragDataLocation) (GLuint program, const GLchar *name);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniform1ui) (GLint location, GLuint v0);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniform2ui) (GLint location, GLuint v0, GLuint v1);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniform3ui) (GLint location, GLuint v0, GLuint v1, GLuint v2);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniform4ui) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniform1uiv) (GLint location, GLsizei count, const GLuint* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniform2uiv) (GLint location, GLsizei count, const GLuint* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniform3uiv) (GLint location, GLsizei count, const GLuint* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniform4uiv) (GLint location, GLsizei count, const GLuint* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glClearBufferiv) (GLenum buffer, GLint drawbuffer, const GLint* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glClearBufferuiv) (GLenum buffer, GLint drawbuffer, const GLuint* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glClearBufferfv) (GLenum buffer, GLint drawbuffer, const GLfloat* value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glClearBufferfi) (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
|
||||
extern GL_APICALL const GLubyte* (* GL_APIENTRY glGetStringi) (GLenum name, GLuint index);
|
||||
extern GL_APICALL void (* GL_APIENTRY glCopyBufferSubData) (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetUniformIndices) (GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetActiveUniformsiv) (GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params);
|
||||
extern GL_APICALL GLuint (* GL_APIENTRY glGetUniformBlockIndex) (GLuint program, const GLchar* uniformBlockName);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetActiveUniformBlockiv) (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetActiveUniformBlockName) (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName);
|
||||
extern GL_APICALL void (* GL_APIENTRY glUniformBlockBinding) (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
|
||||
extern GL_APICALL void (* GL_APIENTRY glDrawArraysInstanced) (GLenum mode, GLint first, GLsizei count, GLsizei instanceCount);
|
||||
extern GL_APICALL void (* GL_APIENTRY glDrawElementsInstanced) (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount);
|
||||
extern GL_APICALL GLsync (* GL_APIENTRY glFenceSync) (GLenum condition, GLbitfield flags);
|
||||
extern GL_APICALL GLboolean (* GL_APIENTRY glIsSync) (GLsync sync);
|
||||
extern GL_APICALL void (* GL_APIENTRY glDeleteSync) (GLsync sync);
|
||||
extern GL_APICALL GLenum (* GL_APIENTRY glClientWaitSync) (GLsync sync, GLbitfield flags, GLuint64 timeout);
|
||||
extern GL_APICALL void (* GL_APIENTRY glWaitSync) (GLsync sync, GLbitfield flags, GLuint64 timeout);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetInteger64v) (GLenum pname, GLint64* params);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetSynciv) (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetInteger64i_v) (GLenum target, GLuint index, GLint64* data);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetBufferParameteri64v) (GLenum target, GLenum pname, GLint64* params);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGenSamplers) (GLsizei count, GLuint* samplers);
|
||||
extern GL_APICALL void (* GL_APIENTRY glDeleteSamplers) (GLsizei count, const GLuint* samplers);
|
||||
extern GL_APICALL GLboolean (* GL_APIENTRY glIsSampler) (GLuint sampler);
|
||||
extern GL_APICALL void (* GL_APIENTRY glBindSampler) (GLuint unit, GLuint sampler);
|
||||
extern GL_APICALL void (* GL_APIENTRY glSamplerParameteri) (GLuint sampler, GLenum pname, GLint param);
|
||||
extern GL_APICALL void (* GL_APIENTRY glSamplerParameteriv) (GLuint sampler, GLenum pname, const GLint* param);
|
||||
extern GL_APICALL void (* GL_APIENTRY glSamplerParameterf) (GLuint sampler, GLenum pname, GLfloat param);
|
||||
extern GL_APICALL void (* GL_APIENTRY glSamplerParameterfv) (GLuint sampler, GLenum pname, const GLfloat* param);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetSamplerParameteriv) (GLuint sampler, GLenum pname, GLint* params);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetSamplerParameterfv) (GLuint sampler, GLenum pname, GLfloat* params);
|
||||
extern GL_APICALL void (* GL_APIENTRY glVertexAttribDivisor) (GLuint index, GLuint divisor);
|
||||
extern GL_APICALL void (* GL_APIENTRY glBindTransformFeedback) (GLenum target, GLuint id);
|
||||
extern GL_APICALL void (* GL_APIENTRY glDeleteTransformFeedbacks) (GLsizei n, const GLuint* ids);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGenTransformFeedbacks) (GLsizei n, GLuint* ids);
|
||||
extern GL_APICALL GLboolean (* GL_APIENTRY glIsTransformFeedback) (GLuint id);
|
||||
extern GL_APICALL void (* GL_APIENTRY glPauseTransformFeedback) (void);
|
||||
extern GL_APICALL void (* GL_APIENTRY glResumeTransformFeedback) (void);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetProgramBinary) (GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary);
|
||||
extern GL_APICALL void (* GL_APIENTRY glProgramBinary) (GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length);
|
||||
extern GL_APICALL void (* GL_APIENTRY glProgramParameteri) (GLuint program, GLenum pname, GLint value);
|
||||
extern GL_APICALL void (* GL_APIENTRY glInvalidateFramebuffer) (GLenum target, GLsizei numAttachments, const GLenum* attachments);
|
||||
extern GL_APICALL void (* GL_APIENTRY glInvalidateSubFramebuffer) (GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height);
|
||||
extern GL_APICALL void (* GL_APIENTRY glTexStorage2D) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
|
||||
extern GL_APICALL void (* GL_APIENTRY glTexStorage3D) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
|
||||
extern GL_APICALL void (* GL_APIENTRY glGetInternalformativ) (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,181 +0,0 @@
|
||||
/*
|
||||
* Copyright 2013 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include "interpolator.h"
|
||||
#include <math.h>
|
||||
#include "interpolator.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
//-------------------------------------------------
|
||||
//Ctor
|
||||
//-------------------------------------------------
|
||||
Interpolator::Interpolator()
|
||||
{
|
||||
list_params_.clear();
|
||||
}
|
||||
|
||||
//-------------------------------------------------
|
||||
//Dtor
|
||||
//-------------------------------------------------
|
||||
Interpolator::~Interpolator()
|
||||
{
|
||||
list_params_.clear();
|
||||
}
|
||||
|
||||
void Interpolator::Clear()
|
||||
{
|
||||
list_params_.clear();
|
||||
}
|
||||
|
||||
Interpolator& Interpolator::Set( const float start,
|
||||
const float dest,
|
||||
const INTERPOLATOR_TYPE type,
|
||||
const double duration )
|
||||
{
|
||||
//init the parameters for the interpolation process
|
||||
start_time_ = PerfMonitor::GetCurrentTime();
|
||||
dest_time_ = start_time_ + duration;
|
||||
type_ = type;
|
||||
|
||||
start_value_ = start;
|
||||
dest_value_ = dest;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Interpolator& Interpolator::Add( const float dest,
|
||||
const INTERPOLATOR_TYPE type,
|
||||
const double duration )
|
||||
{
|
||||
InterpolatorParams param;
|
||||
param.dest_value_ = dest;
|
||||
param.type_ = type;
|
||||
param.duration_ = duration;
|
||||
list_params_.push_back( param );
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool Interpolator::Update( const double current_time, float& p )
|
||||
{
|
||||
bool bContinue;
|
||||
if( current_time >= dest_time_ )
|
||||
{
|
||||
p = dest_value_;
|
||||
if( list_params_.size() )
|
||||
{
|
||||
InterpolatorParams& item = list_params_.front();
|
||||
Set( dest_value_, item.dest_value_, item.type_, item.duration_ );
|
||||
list_params_.pop_front();
|
||||
|
||||
bContinue = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
bContinue = false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
float t = (float) (current_time - start_time_);
|
||||
float d = (float) (dest_time_ - start_time_);
|
||||
float b = start_value_;
|
||||
float c = dest_value_ - start_value_;
|
||||
p = GetFormula( type_, t, b, d, c );
|
||||
|
||||
bContinue = true;
|
||||
}
|
||||
return bContinue;
|
||||
}
|
||||
|
||||
float Interpolator::GetFormula( const INTERPOLATOR_TYPE type,
|
||||
const float t,
|
||||
const float b,
|
||||
const float d,
|
||||
const float c )
|
||||
{
|
||||
float t1;
|
||||
switch( type )
|
||||
{
|
||||
case INTERPOLATOR_TYPE_LINEAR:
|
||||
// simple linear interpolation - no easing
|
||||
return (c * t / d + b);
|
||||
|
||||
case INTERPOLATOR_TYPE_EASEINQUAD:
|
||||
// quadratic (t^2) easing in - accelerating from zero velocity
|
||||
t1 = t / d;
|
||||
return (c * t1 * t1 + b);
|
||||
|
||||
case INTERPOLATOR_TYPE_EASEOUTQUAD:
|
||||
// quadratic (t^2) easing out - decelerating to zero velocity
|
||||
t1 = t / d;
|
||||
return (-c * t1 * (t1 - 2) + b);
|
||||
|
||||
case INTERPOLATOR_TYPE_EASEINOUTQUAD:
|
||||
// quadratic easing in/out - acceleration until halfway, then deceleration
|
||||
t1 = t / d / 2;
|
||||
if( t1 < 1 )
|
||||
return (c / 2 * t1 * t1 + b);
|
||||
else
|
||||
{
|
||||
t1 = t1 - 1;
|
||||
return (-c / 2 * (t1 * (t1 - 2) - 1) + b);
|
||||
}
|
||||
case INTERPOLATOR_TYPE_EASEINCUBIC:
|
||||
// cubic easing in - accelerating from zero velocity
|
||||
t1 = t / d;
|
||||
return (c * t1 * t1 * t1 + b);
|
||||
|
||||
case INTERPOLATOR_TYPE_EASEOUTCUBIC:
|
||||
// cubic easing in - accelerating from zero velocity
|
||||
t1 = t / d - 1;
|
||||
return (c * (t1 * t1 * t1 + 1) + b);
|
||||
|
||||
case INTERPOLATOR_TYPE_EASEINOUTCUBIC:
|
||||
// cubic easing in - accelerating from zero velocity
|
||||
t1 = t / d / 2;
|
||||
|
||||
if( t1 < 1 )
|
||||
return (c / 2 * t1 * t1 * t1 + b);
|
||||
else
|
||||
{
|
||||
t1 -= 2;
|
||||
return (c / 2 * (t1 * t1 * t1 + 2) + b);
|
||||
}
|
||||
case INTERPOLATOR_TYPE_EASEINQUART:
|
||||
// quartic easing in - accelerating from zero velocity
|
||||
t1 = t / d;
|
||||
return (c * t1 * t1 * t1 * t1 + b);
|
||||
|
||||
case INTERPOLATOR_TYPE_EASEINEXPO:
|
||||
// exponential (2^t) easing in - accelerating from zero velocity
|
||||
if( t == 0 )
|
||||
return b;
|
||||
else
|
||||
return (c * powf( 2, (10 * (t / d - 1)) ) + b);
|
||||
|
||||
case INTERPOLATOR_TYPE_EASEOUTEXPO:
|
||||
// exponential (2^t) easing out - decelerating to zero velocity
|
||||
if( t == d )
|
||||
return (b + c);
|
||||
else
|
||||
return (c * (-powf( 2, -10 * t / d ) + 1) + b);
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
} //namespace ndkHelper
|
||||
@@ -1,89 +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.
|
||||
*/
|
||||
|
||||
#ifndef INTERPOLATOR_H_
|
||||
#define INTERPOLATOR_H_
|
||||
|
||||
#include <jni.h>
|
||||
#include <errno.h>
|
||||
#include <time.h>
|
||||
#include "JNIHelper.h"
|
||||
#include "perfMonitor.h"
|
||||
#include <list>
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
enum INTERPOLATOR_TYPE
|
||||
{
|
||||
INTERPOLATOR_TYPE_LINEAR,
|
||||
INTERPOLATOR_TYPE_EASEINQUAD,
|
||||
INTERPOLATOR_TYPE_EASEOUTQUAD,
|
||||
INTERPOLATOR_TYPE_EASEINOUTQUAD,
|
||||
INTERPOLATOR_TYPE_EASEINCUBIC,
|
||||
INTERPOLATOR_TYPE_EASEOUTCUBIC,
|
||||
INTERPOLATOR_TYPE_EASEINOUTCUBIC,
|
||||
INTERPOLATOR_TYPE_EASEINQUART,
|
||||
INTERPOLATOR_TYPE_EASEINEXPO,
|
||||
INTERPOLATOR_TYPE_EASEOUTEXPO,
|
||||
};
|
||||
|
||||
struct InterpolatorParams
|
||||
{
|
||||
float dest_value_;
|
||||
INTERPOLATOR_TYPE type_;
|
||||
double duration_;
|
||||
};
|
||||
|
||||
/******************************************************************
|
||||
* Interpolates values with several interpolation methods
|
||||
*/
|
||||
class Interpolator
|
||||
{
|
||||
private:
|
||||
double start_time_;
|
||||
double dest_time_;
|
||||
INTERPOLATOR_TYPE type_;
|
||||
|
||||
float start_value_;
|
||||
float dest_value_;
|
||||
std::list<InterpolatorParams> list_params_;
|
||||
|
||||
float GetFormula( const INTERPOLATOR_TYPE type,
|
||||
const float t,
|
||||
const float b,
|
||||
const float d,
|
||||
const float c );
|
||||
public:
|
||||
Interpolator();
|
||||
~Interpolator();
|
||||
|
||||
Interpolator& Set( const float start,
|
||||
const float dest,
|
||||
const INTERPOLATOR_TYPE type,
|
||||
double duration );
|
||||
|
||||
Interpolator& Add( const float dest,
|
||||
const INTERPOLATOR_TYPE type,
|
||||
const double duration );
|
||||
|
||||
bool Update( const double currentTime, float& p );
|
||||
|
||||
void Clear();
|
||||
};
|
||||
|
||||
} //namespace ndkHelper
|
||||
#endif /* INTERPOLATOR_H_ */
|
||||
@@ -1,72 +0,0 @@
|
||||
/*
|
||||
* Copyright 2013 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include "perfMonitor.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
PerfMonitor::PerfMonitor() :
|
||||
last_tick_( 0.f ),
|
||||
tv_last_sec_( 0 ),
|
||||
tickindex_( 0 ),
|
||||
ticksum_( 0 )
|
||||
{
|
||||
for( int32_t i = 0; i < NUM_SAMPLES; ++i )
|
||||
ticklist_[i] = 0;
|
||||
}
|
||||
|
||||
PerfMonitor::~PerfMonitor()
|
||||
{
|
||||
}
|
||||
|
||||
double PerfMonitor::UpdateTick( double currentTick )
|
||||
{
|
||||
ticksum_ -= ticklist_[tickindex_];
|
||||
ticksum_ += currentTick;
|
||||
ticklist_[tickindex_] = currentTick;
|
||||
tickindex_ = (tickindex_ + 1) % NUM_SAMPLES;
|
||||
|
||||
return ((double) ticksum_ / NUM_SAMPLES);
|
||||
}
|
||||
|
||||
bool PerfMonitor::Update( float &fFPS )
|
||||
{
|
||||
struct timeval Time;
|
||||
gettimeofday( &Time, NULL );
|
||||
|
||||
double time = Time.tv_sec + Time.tv_usec * 1.0 / 1000000.0;
|
||||
double tick = time - last_tick_;
|
||||
double d = UpdateTick( tick );
|
||||
last_tick_ = time;
|
||||
|
||||
if( Time.tv_sec - tv_last_sec_ >= 1 )
|
||||
{
|
||||
double time = Time.tv_sec + Time.tv_usec * 1.0 / 1000000.0;
|
||||
current_FPS_ = 1.f / d;
|
||||
tv_last_sec_ = Time.tv_sec;
|
||||
fFPS = current_FPS_;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
fFPS = current_FPS_;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
} //namespace ndkHelper
|
||||
|
||||
@@ -1,61 +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.
|
||||
*/
|
||||
|
||||
#ifndef PERFMONITOR_H_
|
||||
#define PERFMONITOR_H_
|
||||
|
||||
#include <jni.h>
|
||||
#include <errno.h>
|
||||
#include <time.h>
|
||||
#include "JNIHelper.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
const int32_t NUM_SAMPLES = 100;
|
||||
|
||||
/******************************************************************
|
||||
* Helper class for a performance monitoring and get current tick time
|
||||
*/
|
||||
class PerfMonitor
|
||||
{
|
||||
private:
|
||||
float current_FPS_;
|
||||
time_t tv_last_sec_;
|
||||
|
||||
double last_tick_;
|
||||
int32_t tickindex_;
|
||||
double ticksum_;
|
||||
double ticklist_[NUM_SAMPLES];
|
||||
|
||||
double UpdateTick( double current_tick );
|
||||
public:
|
||||
PerfMonitor();
|
||||
virtual ~PerfMonitor();
|
||||
|
||||
bool Update( float &fFPS );
|
||||
|
||||
static double GetCurrentTime()
|
||||
{
|
||||
struct timeval time;
|
||||
gettimeofday( &time, NULL );
|
||||
double ret = time.tv_sec + time.tv_usec * 1.0 / 1000000.0;
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
} //namespace ndkHelper
|
||||
#endif /* PERFMONITOR_H_ */
|
||||
@@ -1,192 +0,0 @@
|
||||
/*
|
||||
* Copyright 2013 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include <EGL/egl.h>
|
||||
#include <GLES2/gl2.h>
|
||||
|
||||
#include "shader.h"
|
||||
#include "JNIHelper.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
#define DEBUG (1)
|
||||
|
||||
bool shader::CompileShader( GLuint *shader,
|
||||
const GLenum type,
|
||||
const char *str_file_name,
|
||||
const std::map<std::string, std::string>& map_parameters )
|
||||
{
|
||||
std::vector<uint8_t> data;
|
||||
if( !JNIHelper::GetInstance()->ReadFile( str_file_name, &data ) )
|
||||
{
|
||||
LOGI( "Can not open a file:%s", str_file_name );
|
||||
return false;
|
||||
}
|
||||
|
||||
const char REPLACEMENT_TAG = '*';
|
||||
//Fill-in parameters
|
||||
std::string str( data.begin(), data.end() );
|
||||
std::string str_replacement_map( data.size(), ' ' );
|
||||
|
||||
std::map<std::string, std::string>::const_iterator it = map_parameters.begin();
|
||||
std::map<std::string, std::string>::const_iterator itEnd = map_parameters.end();
|
||||
while( it != itEnd )
|
||||
{
|
||||
size_t pos = 0;
|
||||
while( (pos = str.find( it->first, pos )) != std::string::npos )
|
||||
{
|
||||
//Check if the sub string is already touched
|
||||
|
||||
size_t replaced_pos = str_replacement_map.find( REPLACEMENT_TAG, pos );
|
||||
if( replaced_pos == std::string::npos || replaced_pos > pos )
|
||||
{
|
||||
|
||||
str.replace( pos, it->first.length(), it->second );
|
||||
str_replacement_map.replace( pos, it->first.length(), it->first.length(),
|
||||
REPLACEMENT_TAG );
|
||||
pos += it->second.length();
|
||||
}
|
||||
else
|
||||
{
|
||||
//The replacement target has been touched by other tag, skipping them
|
||||
pos += it->second.length();
|
||||
}
|
||||
}
|
||||
it++;
|
||||
}
|
||||
|
||||
LOGI( "Patched Shdader:\n%s", str.c_str() );
|
||||
|
||||
std::vector<uint8_t> v( str.begin(), str.end() );
|
||||
str.clear();
|
||||
return shader::CompileShader( shader, type, v );
|
||||
}
|
||||
|
||||
bool shader::CompileShader( GLuint *shader,
|
||||
const GLenum type,
|
||||
const GLchar *source,
|
||||
const int32_t iSize )
|
||||
{
|
||||
if( source == NULL || iSize <= 0 )
|
||||
return false;
|
||||
|
||||
*shader = glCreateShader( type );
|
||||
glShaderSource( *shader, 1, &source, &iSize ); //Not specifying 3rd parameter (size) could be troublesome..
|
||||
|
||||
glCompileShader( *shader );
|
||||
|
||||
#if defined(DEBUG)
|
||||
GLint logLength;
|
||||
glGetShaderiv( *shader, GL_INFO_LOG_LENGTH, &logLength );
|
||||
if( logLength > 0 )
|
||||
{
|
||||
GLchar *log = (GLchar *) malloc( logLength );
|
||||
glGetShaderInfoLog( *shader, logLength, &logLength, log );
|
||||
LOGI( "Shader compile log:\n%s", log );
|
||||
free( log );
|
||||
}
|
||||
#endif
|
||||
|
||||
GLint status;
|
||||
glGetShaderiv( *shader, GL_COMPILE_STATUS, &status );
|
||||
if( status == 0 )
|
||||
{
|
||||
glDeleteShader( *shader );
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool shader::CompileShader( GLuint *shader,
|
||||
const GLenum type,
|
||||
std::vector<uint8_t>& data )
|
||||
{
|
||||
if( !data.size() )
|
||||
return false;
|
||||
|
||||
const GLchar *source = (GLchar *) &data[0];
|
||||
int32_t iSize = data.size();
|
||||
return shader::CompileShader( shader, type, source, iSize );
|
||||
}
|
||||
|
||||
bool shader::CompileShader( GLuint *shader,
|
||||
const GLenum type,
|
||||
const char *strFileName )
|
||||
{
|
||||
std::vector<uint8_t> data;
|
||||
bool b = JNIHelper::GetInstance()->ReadFile( strFileName, &data );
|
||||
if( !b )
|
||||
{
|
||||
LOGI( "Can not open a file:%s", strFileName );
|
||||
return false;
|
||||
}
|
||||
|
||||
return shader::CompileShader( shader, type, data );
|
||||
}
|
||||
|
||||
bool shader::LinkProgram( const GLuint prog )
|
||||
{
|
||||
GLint status;
|
||||
|
||||
glLinkProgram( prog );
|
||||
|
||||
#if defined(DEBUG)
|
||||
GLint logLength;
|
||||
glGetProgramiv( prog, GL_INFO_LOG_LENGTH, &logLength );
|
||||
if( logLength > 0 )
|
||||
{
|
||||
GLchar *log = (GLchar *) malloc( logLength );
|
||||
glGetProgramInfoLog( prog, logLength, &logLength, log );
|
||||
LOGI( "Program link log:\n%s", log );
|
||||
free( log );
|
||||
}
|
||||
#endif
|
||||
|
||||
glGetProgramiv( prog, GL_LINK_STATUS, &status );
|
||||
if( status == 0 )
|
||||
{
|
||||
LOGI( "Program link failed\n" );
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool shader::ValidateProgram( const GLuint prog )
|
||||
{
|
||||
GLint logLength, status;
|
||||
|
||||
glValidateProgram( prog );
|
||||
glGetProgramiv( prog, GL_INFO_LOG_LENGTH, &logLength );
|
||||
if( logLength > 0 )
|
||||
{
|
||||
GLchar *log = (GLchar *) malloc( logLength );
|
||||
glGetProgramInfoLog( prog, logLength, &logLength, log );
|
||||
LOGI( "Program validate log:\n%s", log );
|
||||
free( log );
|
||||
}
|
||||
|
||||
glGetProgramiv( prog, GL_VALIDATE_STATUS, &status );
|
||||
if( status == 0 )
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
} //namespace ndkHelper
|
||||
|
||||
@@ -1,124 +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.
|
||||
*/
|
||||
|
||||
#ifndef SHADER_H_
|
||||
#define SHADER_H_
|
||||
|
||||
#include <jni.h>
|
||||
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <string>
|
||||
|
||||
#include <EGL/egl.h>
|
||||
#include <GLES/gl.h>
|
||||
|
||||
#include <android/log.h>
|
||||
|
||||
#include "JNIHelper.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
namespace shader
|
||||
{
|
||||
|
||||
/******************************************************************
|
||||
* Shader compiler helper
|
||||
* namespace: ndkHelper::shader
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************
|
||||
* CompileShader() with vector
|
||||
*
|
||||
* arguments:
|
||||
* out: shader, shader variable
|
||||
* in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
|
||||
* in: data, source vector
|
||||
* return: true if a shader compilation succeeded, false if it failed
|
||||
*
|
||||
*/
|
||||
bool CompileShader( GLuint *shader, const GLenum type, std::vector<uint8_t>& data );
|
||||
|
||||
/******************************************************************
|
||||
* CompileShader() with buffer
|
||||
*
|
||||
* arguments:
|
||||
* out: shader, shader variable
|
||||
* in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
|
||||
* in: source, source buffer
|
||||
* in: iSize, buffer size
|
||||
* return: true if a shader compilation succeeded, false if it failed
|
||||
*
|
||||
*/
|
||||
bool CompileShader( GLuint *shader,
|
||||
const GLenum type,
|
||||
const GLchar *source,
|
||||
const int32_t iSize );
|
||||
|
||||
/******************************************************************
|
||||
* CompileShader() with filename
|
||||
*
|
||||
* arguments:
|
||||
* out: shader, shader variable
|
||||
* in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
|
||||
* in: strFilename, filename
|
||||
* return: true if a shader compilation succeeded, false if it failed
|
||||
*
|
||||
*/
|
||||
bool CompileShader( GLuint *shader, const GLenum type, const char *strFileName );
|
||||
|
||||
/******************************************************************
|
||||
* CompileShader() with std::map helps patching on a shader on the fly.
|
||||
*
|
||||
* arguments:
|
||||
* out: shader, shader variable
|
||||
* in: type, shader type (i.e. GL_VERTEX_SHADER/GL_FRAGMENT_SHADER)
|
||||
* in: mapParameters
|
||||
* For a example,
|
||||
* map : %KEY% -> %VALUE% replaces all %KEY% entries in the given shader code to %VALUE"
|
||||
* return: true if a shader compilation succeeded, false if it failed
|
||||
*
|
||||
*/
|
||||
bool CompileShader( GLuint *shader,
|
||||
const GLenum type,
|
||||
const char *str_file_name,
|
||||
const std::map<std::string, std::string>& map_parameters );
|
||||
|
||||
/******************************************************************
|
||||
* LinkProgram()
|
||||
*
|
||||
* arguments:
|
||||
* in: program, program
|
||||
* return: true if a shader linkage succeeded, false if it failed
|
||||
*
|
||||
*/
|
||||
bool LinkProgram( const GLuint prog );
|
||||
|
||||
/******************************************************************
|
||||
* validateProgram()
|
||||
*
|
||||
* arguments:
|
||||
* in: program, program
|
||||
* return: true if a shader validation succeeded, false if it failed
|
||||
*
|
||||
*/
|
||||
bool ValidateProgram( const GLuint prog );
|
||||
} //namespace shader
|
||||
|
||||
} //namespace ndkHelper
|
||||
#endif /* SHADER_H_ */
|
||||
@@ -1,320 +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.
|
||||
*/
|
||||
|
||||
//----------------------------------------------------------
|
||||
// tapCamera.cpp
|
||||
// Camera control with tap
|
||||
//
|
||||
//----------------------------------------------------------
|
||||
#include <fstream>
|
||||
#include "tapCamera.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
const float TRANSFORM_FACTOR = 15.f;
|
||||
const float TRANSFORM_FACTORZ = 10.f;
|
||||
|
||||
const float MOMENTUM_FACTOR_DECREASE = 0.85f;
|
||||
const float MOMENTUM_FACTOR_DECREASE_SHIFT = 0.9f;
|
||||
const float MOMENTUM_FACTOR = 0.8f;
|
||||
const float MOMENTUM_FACTOR_THRESHOLD = 0.001f;
|
||||
|
||||
//----------------------------------------------------------
|
||||
// Ctor
|
||||
//----------------------------------------------------------
|
||||
TapCamera::TapCamera() :
|
||||
dragging_( false ),
|
||||
pinching_( false ),
|
||||
momentum_( false ),
|
||||
ball_radius_( 0.75f ),
|
||||
pinch_start_distance_SQ_( 0.f ),
|
||||
camera_rotation_( 0.f ),
|
||||
camera_rotation_start_( 0.f ),
|
||||
camera_rotation_now_( 0.f ),
|
||||
momemtum_steps_( 0.f ),
|
||||
flip_z_( 0.f )
|
||||
{
|
||||
//Init offset
|
||||
InitParameters();
|
||||
|
||||
vec_flip_ = Vec2( 1.f, -1.f );
|
||||
flip_z_ = -1.f;
|
||||
vec_pinch_transform_factor_ = Vec3( 1.f, 1.f, 1.f );
|
||||
|
||||
vec_ball_center_ = Vec2( 0, 0 );
|
||||
vec_ball_now_ = Vec2( 0, 0 );
|
||||
vec_ball_down_ = Vec2( 0, 0 );
|
||||
|
||||
vec_pinch_start_ = Vec2( 0, 0 );
|
||||
vec_pinch_start_center_ = Vec2( 0, 0 );
|
||||
|
||||
vec_flip_ = Vec2( 0, 0 );
|
||||
|
||||
}
|
||||
|
||||
void TapCamera::InitParameters()
|
||||
{
|
||||
//Init parameters
|
||||
vec_offset_ = Vec3();
|
||||
vec_offset_now_ = Vec3();
|
||||
|
||||
quat_ball_rot_ = Quaternion();
|
||||
quat_ball_now_ = Quaternion();
|
||||
quat_ball_now_.ToMatrix( mat_rotation_ );
|
||||
camera_rotation_ = 0.f;
|
||||
|
||||
vec_drag_delta_ = Vec2();
|
||||
vec_offset_delta_ = Vec3();
|
||||
|
||||
momentum_ = false;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------
|
||||
// Dtor
|
||||
//----------------------------------------------------------
|
||||
TapCamera::~TapCamera()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void TapCamera::Update()
|
||||
{
|
||||
if( momentum_ )
|
||||
{
|
||||
float momenttum_steps = momemtum_steps_;
|
||||
|
||||
//Momentum rotation
|
||||
Vec2 v = vec_drag_delta_;
|
||||
BeginDrag( Vec2() ); //NOTE:This call reset _VDragDelta
|
||||
Drag( v * vec_flip_ );
|
||||
|
||||
//Momentum shift
|
||||
vec_offset_ += vec_offset_delta_;
|
||||
|
||||
BallUpdate();
|
||||
EndDrag();
|
||||
|
||||
//Decrease deltas
|
||||
vec_drag_delta_ = v * MOMENTUM_FACTOR_DECREASE;
|
||||
vec_offset_delta_ = vec_offset_delta_ * MOMENTUM_FACTOR_DECREASE_SHIFT;
|
||||
|
||||
//Count steps
|
||||
momemtum_steps_ = momenttum_steps * MOMENTUM_FACTOR_DECREASE;
|
||||
if( momemtum_steps_ < MOMENTUM_FACTOR_THRESHOLD )
|
||||
{
|
||||
momentum_ = false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
vec_drag_delta_ *= MOMENTUM_FACTOR;
|
||||
vec_offset_delta_ = vec_offset_delta_ * MOMENTUM_FACTOR;
|
||||
BallUpdate();
|
||||
}
|
||||
|
||||
Vec3 vec = vec_offset_ + vec_offset_now_;
|
||||
Vec3 vec_tmp( TRANSFORM_FACTOR, -TRANSFORM_FACTOR, TRANSFORM_FACTORZ );
|
||||
|
||||
vec *= vec_tmp * vec_pinch_transform_factor_;
|
||||
|
||||
mat_transform_ = Mat4::Translation( vec );
|
||||
}
|
||||
|
||||
Mat4& TapCamera::GetRotationMatrix()
|
||||
{
|
||||
return mat_rotation_;
|
||||
}
|
||||
|
||||
Mat4& TapCamera::GetTransformMatrix()
|
||||
{
|
||||
return mat_transform_;
|
||||
}
|
||||
|
||||
void TapCamera::Reset( const bool bAnimate )
|
||||
{
|
||||
InitParameters();
|
||||
Update();
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------
|
||||
//Drag control
|
||||
//----------------------------------------------------------
|
||||
void TapCamera::BeginDrag( const Vec2& v )
|
||||
{
|
||||
if( dragging_ )
|
||||
EndDrag();
|
||||
|
||||
if( pinching_ )
|
||||
EndPinch();
|
||||
|
||||
Vec2 vec = v * vec_flip_;
|
||||
vec_ball_now_ = vec;
|
||||
vec_ball_down_ = vec_ball_now_;
|
||||
|
||||
dragging_ = true;
|
||||
momentum_ = false;
|
||||
vec_last_input_ = vec;
|
||||
vec_drag_delta_ = Vec2();
|
||||
}
|
||||
|
||||
void TapCamera::EndDrag()
|
||||
{
|
||||
quat_ball_down_ = quat_ball_now_;
|
||||
quat_ball_rot_ = Quaternion();
|
||||
|
||||
dragging_ = false;
|
||||
momentum_ = true;
|
||||
momemtum_steps_ = 1.0f;
|
||||
}
|
||||
|
||||
void TapCamera::Drag( const Vec2& v )
|
||||
{
|
||||
if( !dragging_ )
|
||||
return;
|
||||
|
||||
Vec2 vec = v * vec_flip_;
|
||||
vec_ball_now_ = vec;
|
||||
|
||||
vec_drag_delta_ = vec_drag_delta_ * MOMENTUM_FACTOR + (vec - vec_last_input_);
|
||||
vec_last_input_ = vec;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------
|
||||
//Pinch controll
|
||||
//----------------------------------------------------------
|
||||
void TapCamera::BeginPinch( const Vec2& v1, const Vec2& v2 )
|
||||
{
|
||||
if( dragging_ )
|
||||
EndDrag();
|
||||
|
||||
if( pinching_ )
|
||||
EndPinch();
|
||||
|
||||
BeginDrag( Vec2() );
|
||||
|
||||
vec_pinch_start_center_ = (v1 + v2) / 2.f;
|
||||
|
||||
Vec2 vec = v1 - v2;
|
||||
float x_diff;
|
||||
float y_diff;
|
||||
vec.Value( x_diff, y_diff );
|
||||
|
||||
pinch_start_distance_SQ_ = x_diff * x_diff + y_diff * y_diff;
|
||||
camera_rotation_start_ = atan2f( y_diff, x_diff );
|
||||
camera_rotation_now_ = 0;
|
||||
|
||||
pinching_ = true;
|
||||
momentum_ = false;
|
||||
|
||||
//Init momentum factors
|
||||
vec_offset_delta_ = Vec3();
|
||||
}
|
||||
|
||||
void TapCamera::EndPinch()
|
||||
{
|
||||
pinching_ = false;
|
||||
momentum_ = true;
|
||||
momemtum_steps_ = 1.f;
|
||||
vec_offset_ += vec_offset_now_;
|
||||
camera_rotation_ += camera_rotation_now_;
|
||||
vec_offset_now_ = Vec3();
|
||||
|
||||
camera_rotation_now_ = 0;
|
||||
|
||||
EndDrag();
|
||||
}
|
||||
|
||||
void TapCamera::Pinch( const Vec2& v1, const Vec2& v2 )
|
||||
{
|
||||
if( !pinching_ )
|
||||
return;
|
||||
|
||||
//Update momentum factor
|
||||
vec_offset_last_ = vec_offset_now_;
|
||||
|
||||
float x_diff, y_diff;
|
||||
Vec2 vec = v1 - v2;
|
||||
vec.Value( x_diff, y_diff );
|
||||
|
||||
float fDistanceSQ = x_diff * x_diff + y_diff * y_diff;
|
||||
|
||||
float f = pinch_start_distance_SQ_ / fDistanceSQ;
|
||||
if( f < 1.f )
|
||||
f = -1.f / f + 1.0f;
|
||||
else
|
||||
f = f - 1.f;
|
||||
if( isnan( f ) )
|
||||
f = 0.f;
|
||||
|
||||
vec = (v1 + v2) / 2.f - vec_pinch_start_center_;
|
||||
vec_offset_now_ = Vec3( vec, flip_z_ * f );
|
||||
|
||||
//Update momentum factor
|
||||
vec_offset_delta_ = vec_offset_delta_ * MOMENTUM_FACTOR
|
||||
+ (vec_offset_now_ - vec_offset_last_);
|
||||
|
||||
//
|
||||
//Update ration quaternion
|
||||
float fRotation = atan2f( y_diff, x_diff );
|
||||
camera_rotation_now_ = fRotation - camera_rotation_start_;
|
||||
|
||||
//Trackball rotation
|
||||
quat_ball_rot_ = Quaternion( 0.f, 0.f, sinf( -camera_rotation_now_ * 0.5f ),
|
||||
cosf( -camera_rotation_now_ * 0.5f ) );
|
||||
}
|
||||
|
||||
//----------------------------------------------------------
|
||||
//Trackball controll
|
||||
//----------------------------------------------------------
|
||||
void TapCamera::BallUpdate()
|
||||
{
|
||||
if( dragging_ )
|
||||
{
|
||||
Vec3 vec_from = PointOnSphere( vec_ball_down_ );
|
||||
Vec3 vec_to = PointOnSphere( vec_ball_now_ );
|
||||
|
||||
Vec3 vec = vec_from.Cross( vec_to );
|
||||
float w = vec_from.Dot( vec_to );
|
||||
|
||||
Quaternion qDrag = Quaternion( vec, w );
|
||||
qDrag = qDrag * quat_ball_down_;
|
||||
quat_ball_now_ = quat_ball_rot_ * qDrag;
|
||||
}
|
||||
quat_ball_now_.ToMatrix( mat_rotation_ );
|
||||
}
|
||||
|
||||
Vec3 TapCamera::PointOnSphere( Vec2& point )
|
||||
{
|
||||
Vec3 ball_mouse;
|
||||
float mag;
|
||||
Vec2 vec = (point - vec_ball_center_) / ball_radius_;
|
||||
mag = vec.Dot( vec );
|
||||
if( mag > 1.f )
|
||||
{
|
||||
float scale = 1.f / sqrtf( mag );
|
||||
vec *= scale;
|
||||
ball_mouse = Vec3( vec, 0.f );
|
||||
}
|
||||
else
|
||||
{
|
||||
ball_mouse = Vec3( vec, sqrtf( 1.f - mag ) );
|
||||
}
|
||||
return ball_mouse;
|
||||
}
|
||||
|
||||
} //namespace ndkHelper
|
||||
@@ -1,112 +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.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <GLES2/gl2.h>
|
||||
|
||||
#include "JNIHelper.h"
|
||||
#include "vecmath.h"
|
||||
#include "interpolator.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
/******************************************************************
|
||||
* Camera control helper class with a tap gesture
|
||||
* This class is mainly used for 3D space camera control in samples.
|
||||
*
|
||||
*/
|
||||
class TapCamera
|
||||
{
|
||||
private:
|
||||
//Trackball
|
||||
Vec2 vec_ball_center_;
|
||||
float ball_radius_;
|
||||
Quaternion quat_ball_now_;
|
||||
Quaternion quat_ball_down_;
|
||||
Vec2 vec_ball_now_;
|
||||
Vec2 vec_ball_down_;
|
||||
Quaternion quat_ball_rot_;
|
||||
|
||||
bool dragging_;
|
||||
bool pinching_;
|
||||
|
||||
//Pinch related info
|
||||
Vec2 vec_pinch_start_;
|
||||
Vec2 vec_pinch_start_center_;
|
||||
float pinch_start_distance_SQ_;
|
||||
|
||||
//Camera shift
|
||||
Vec3 vec_offset_;
|
||||
Vec3 vec_offset_now_;
|
||||
|
||||
//Camera Rotation
|
||||
float camera_rotation_;
|
||||
float camera_rotation_start_;
|
||||
float camera_rotation_now_;
|
||||
|
||||
//Momentum support
|
||||
bool momentum_;
|
||||
Vec2 vec_drag_delta_;
|
||||
Vec2 vec_last_input_;
|
||||
Vec3 vec_offset_last_;
|
||||
Vec3 vec_offset_delta_;
|
||||
float momemtum_steps_;
|
||||
|
||||
Vec2 vec_flip_;
|
||||
float flip_z_;
|
||||
|
||||
Mat4 mat_rotation_;
|
||||
Mat4 mat_transform_;
|
||||
|
||||
Vec3 vec_pinch_transform_factor_;
|
||||
|
||||
Vec3 PointOnSphere( Vec2& point );
|
||||
void BallUpdate();
|
||||
void InitParameters();
|
||||
public:
|
||||
TapCamera();
|
||||
virtual ~TapCamera();
|
||||
void BeginDrag( const Vec2& vec );
|
||||
void EndDrag();
|
||||
void Drag( const Vec2& vec );
|
||||
void Update();
|
||||
|
||||
Mat4& GetRotationMatrix();
|
||||
Mat4& GetTransformMatrix();
|
||||
|
||||
void BeginPinch( const Vec2& v1, const Vec2& v2 );
|
||||
void EndPinch();
|
||||
void Pinch( const Vec2& v1, const Vec2& v2 );
|
||||
|
||||
void SetFlip( const float x, const float y, const float z )
|
||||
{
|
||||
vec_flip_ = Vec2( x, y );
|
||||
flip_z_ = z;
|
||||
}
|
||||
|
||||
void SetPinchTransformFactor( const float x, const float y, const float z )
|
||||
{
|
||||
vec_pinch_transform_factor_ = Vec3( x, y, z );
|
||||
}
|
||||
|
||||
void Reset( const bool bAnimate );
|
||||
|
||||
};
|
||||
|
||||
} //namespace ndkHelper
|
||||
@@ -1,379 +0,0 @@
|
||||
/*
|
||||
* Copy_right 2013 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* y_ou may_ not use this file ex_cept in compliance with the License.
|
||||
* You may_ obtain a copy_ of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by_ applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either ex_press or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// vecmath.cpp
|
||||
//--------------------------------------------------------------------------------
|
||||
#include "vecmath.h"
|
||||
|
||||
namespace ndk_helper
|
||||
{
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// vec3
|
||||
//--------------------------------------------------------------------------------
|
||||
Vec3::Vec3( const Vec4& vec )
|
||||
{
|
||||
x_ = vec.x_;
|
||||
y_ = vec.y_;
|
||||
z_ = vec.z_;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// vec4
|
||||
//--------------------------------------------------------------------------------
|
||||
Vec4 Vec4::operator*( const Mat4& rhs ) const
|
||||
{
|
||||
Vec4 out;
|
||||
out.x_ = x_ * rhs.f_[0] + y_ * rhs.f_[1] + z_ * rhs.f_[2] + w_ * rhs.f_[3];
|
||||
out.y_ = x_ * rhs.f_[4] + y_ * rhs.f_[5] + z_ * rhs.f_[6] + w_ * rhs.f_[7];
|
||||
out.z_ = x_ * rhs.f_[8] + y_ * rhs.f_[9] + z_ * rhs.f_[10] + w_ * rhs.f_[11];
|
||||
out.w_ = x_ * rhs.f_[12] + y_ * rhs.f_[13] + z_ * rhs.f_[14] + w_ * rhs.f_[15];
|
||||
return out;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// mat4
|
||||
//--------------------------------------------------------------------------------
|
||||
Mat4::Mat4()
|
||||
{
|
||||
for( int32_t i = 0; i < 16; ++i )
|
||||
f_[i] = 0.f;
|
||||
}
|
||||
|
||||
Mat4::Mat4( const float* mIn )
|
||||
{
|
||||
for( int32_t i = 0; i < 16; ++i )
|
||||
f_[i] = mIn[i];
|
||||
}
|
||||
|
||||
Mat4 Mat4::operator*( const Mat4& rhs ) const
|
||||
{
|
||||
Mat4 ret;
|
||||
ret.f_[0] = f_[0] * rhs.f_[0] + f_[4] * rhs.f_[1] + f_[8] * rhs.f_[2]
|
||||
+ f_[12] * rhs.f_[3];
|
||||
ret.f_[1] = f_[1] * rhs.f_[0] + f_[5] * rhs.f_[1] + f_[9] * rhs.f_[2]
|
||||
+ f_[13] * rhs.f_[3];
|
||||
ret.f_[2] = f_[2] * rhs.f_[0] + f_[6] * rhs.f_[1] + f_[10] * rhs.f_[2]
|
||||
+ f_[14] * rhs.f_[3];
|
||||
ret.f_[3] = f_[3] * rhs.f_[0] + f_[7] * rhs.f_[1] + f_[11] * rhs.f_[2]
|
||||
+ f_[15] * rhs.f_[3];
|
||||
|
||||
ret.f_[4] = f_[0] * rhs.f_[4] + f_[4] * rhs.f_[5] + f_[8] * rhs.f_[6]
|
||||
+ f_[12] * rhs.f_[7];
|
||||
ret.f_[5] = f_[1] * rhs.f_[4] + f_[5] * rhs.f_[5] + f_[9] * rhs.f_[6]
|
||||
+ f_[13] * rhs.f_[7];
|
||||
ret.f_[6] = f_[2] * rhs.f_[4] + f_[6] * rhs.f_[5] + f_[10] * rhs.f_[6]
|
||||
+ f_[14] * rhs.f_[7];
|
||||
ret.f_[7] = f_[3] * rhs.f_[4] + f_[7] * rhs.f_[5] + f_[11] * rhs.f_[6]
|
||||
+ f_[15] * rhs.f_[7];
|
||||
|
||||
ret.f_[8] = f_[0] * rhs.f_[8] + f_[4] * rhs.f_[9] + f_[8] * rhs.f_[10]
|
||||
+ f_[12] * rhs.f_[11];
|
||||
ret.f_[9] = f_[1] * rhs.f_[8] + f_[5] * rhs.f_[9] + f_[9] * rhs.f_[10]
|
||||
+ f_[13] * rhs.f_[11];
|
||||
ret.f_[10] = f_[2] * rhs.f_[8] + f_[6] * rhs.f_[9] + f_[10] * rhs.f_[10]
|
||||
+ f_[14] * rhs.f_[11];
|
||||
ret.f_[11] = f_[3] * rhs.f_[8] + f_[7] * rhs.f_[9] + f_[11] * rhs.f_[10]
|
||||
+ f_[15] * rhs.f_[11];
|
||||
|
||||
ret.f_[12] = f_[0] * rhs.f_[12] + f_[4] * rhs.f_[13] + f_[8] * rhs.f_[14]
|
||||
+ f_[12] * rhs.f_[15];
|
||||
ret.f_[13] = f_[1] * rhs.f_[12] + f_[5] * rhs.f_[13] + f_[9] * rhs.f_[14]
|
||||
+ f_[13] * rhs.f_[15];
|
||||
ret.f_[14] = f_[2] * rhs.f_[12] + f_[6] * rhs.f_[13] + f_[10] * rhs.f_[14]
|
||||
+ f_[14] * rhs.f_[15];
|
||||
ret.f_[15] = f_[3] * rhs.f_[12] + f_[7] * rhs.f_[13] + f_[11] * rhs.f_[14]
|
||||
+ f_[15] * rhs.f_[15];
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
Vec4 Mat4::operator*( const Vec4& rhs ) const
|
||||
{
|
||||
Vec4 ret;
|
||||
ret.x_ = rhs.x_ * f_[0] + rhs.y_ * f_[4] + rhs.z_ * f_[8] + rhs.w_ * f_[12];
|
||||
ret.y_ = rhs.x_ * f_[1] + rhs.y_ * f_[5] + rhs.z_ * f_[9] + rhs.w_ * f_[13];
|
||||
ret.z_ = rhs.x_ * f_[2] + rhs.y_ * f_[6] + rhs.z_ * f_[10] + rhs.w_ * f_[14];
|
||||
ret.w_ = rhs.x_ * f_[3] + rhs.y_ * f_[7] + rhs.z_ * f_[11] + rhs.w_ * f_[15];
|
||||
return ret;
|
||||
}
|
||||
|
||||
Mat4 Mat4::Inverse()
|
||||
{
|
||||
Mat4 ret;
|
||||
float det_1;
|
||||
float pos = 0;
|
||||
float neg = 0;
|
||||
float temp;
|
||||
|
||||
temp = f_[0] * f_[5] * f_[10];
|
||||
if( temp >= 0 )
|
||||
pos += temp;
|
||||
else
|
||||
neg += temp;
|
||||
temp = f_[4] * f_[9] * f_[2];
|
||||
if( temp >= 0 )
|
||||
pos += temp;
|
||||
else
|
||||
neg += temp;
|
||||
temp = f_[8] * f_[1] * f_[6];
|
||||
if( temp >= 0 )
|
||||
pos += temp;
|
||||
else
|
||||
neg += temp;
|
||||
temp = -f_[8] * f_[5] * f_[2];
|
||||
if( temp >= 0 )
|
||||
pos += temp;
|
||||
else
|
||||
neg += temp;
|
||||
temp = -f_[4] * f_[1] * f_[10];
|
||||
if( temp >= 0 )
|
||||
pos += temp;
|
||||
else
|
||||
neg += temp;
|
||||
temp = -f_[0] * f_[9] * f_[6];
|
||||
if( temp >= 0 )
|
||||
pos += temp;
|
||||
else
|
||||
neg += temp;
|
||||
det_1 = pos + neg;
|
||||
|
||||
if( det_1 == 0.0 )
|
||||
{
|
||||
//Error
|
||||
}
|
||||
else
|
||||
{
|
||||
det_1 = 1.0f / det_1;
|
||||
ret.f_[0] = (f_[5] * f_[10] - f_[9] * f_[6]) * det_1;
|
||||
ret.f_[1] = -(f_[1] * f_[10] - f_[9] * f_[2]) * det_1;
|
||||
ret.f_[2] = (f_[1] * f_[6] - f_[5] * f_[2]) * det_1;
|
||||
ret.f_[4] = -(f_[4] * f_[10] - f_[8] * f_[6]) * det_1;
|
||||
ret.f_[5] = (f_[0] * f_[10] - f_[8] * f_[2]) * det_1;
|
||||
ret.f_[6] = -(f_[0] * f_[6] - f_[4] * f_[2]) * det_1;
|
||||
ret.f_[8] = (f_[4] * f_[9] - f_[8] * f_[5]) * det_1;
|
||||
ret.f_[9] = -(f_[0] * f_[9] - f_[8] * f_[1]) * det_1;
|
||||
ret.f_[10] = (f_[0] * f_[5] - f_[4] * f_[1]) * det_1;
|
||||
|
||||
/* Calculate -C * inverse(A) */
|
||||
ret.f_[12] = -(f_[12] * ret.f_[0] + f_[13] * ret.f_[4] + f_[14] * ret.f_[8]);
|
||||
ret.f_[13] = -(f_[12] * ret.f_[1] + f_[13] * ret.f_[5] + f_[14] * ret.f_[9]);
|
||||
ret.f_[14] = -(f_[12] * ret.f_[2] + f_[13] * ret.f_[6] + f_[14] * ret.f_[10]);
|
||||
|
||||
ret.f_[3] = 0.0f;
|
||||
ret.f_[7] = 0.0f;
|
||||
ret.f_[11] = 0.0f;
|
||||
ret.f_[15] = 1.0f;
|
||||
}
|
||||
|
||||
*this = ret;
|
||||
return *this;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// Misc
|
||||
//--------------------------------------------------------------------------------
|
||||
Mat4 Mat4::RotationX( const float fAngle )
|
||||
{
|
||||
Mat4 ret;
|
||||
float fCosine, fSine;
|
||||
|
||||
fCosine = cosf( fAngle );
|
||||
fSine = sinf( fAngle );
|
||||
|
||||
ret.f_[0] = 1.0f;
|
||||
ret.f_[4] = 0.0f;
|
||||
ret.f_[8] = 0.0f;
|
||||
ret.f_[12] = 0.0f;
|
||||
ret.f_[1] = 0.0f;
|
||||
ret.f_[5] = fCosine;
|
||||
ret.f_[9] = fSine;
|
||||
ret.f_[13] = 0.0f;
|
||||
ret.f_[2] = 0.0f;
|
||||
ret.f_[6] = -fSine;
|
||||
ret.f_[10] = fCosine;
|
||||
ret.f_[14] = 0.0f;
|
||||
ret.f_[3] = 0.0f;
|
||||
ret.f_[7] = 0.0f;
|
||||
ret.f_[11] = 0.0f;
|
||||
ret.f_[15] = 1.0f;
|
||||
return ret;
|
||||
}
|
||||
|
||||
Mat4 Mat4::RotationY( const float fAngle )
|
||||
{
|
||||
Mat4 ret;
|
||||
float fCosine, fSine;
|
||||
|
||||
fCosine = cosf( fAngle );
|
||||
fSine = sinf( fAngle );
|
||||
|
||||
ret.f_[0] = fCosine;
|
||||
ret.f_[4] = 0.0f;
|
||||
ret.f_[8] = -fSine;
|
||||
ret.f_[12] = 0.0f;
|
||||
ret.f_[1] = 0.0f;
|
||||
ret.f_[5] = 1.0f;
|
||||
ret.f_[9] = 0.0f;
|
||||
ret.f_[13] = 0.0f;
|
||||
ret.f_[2] = fSine;
|
||||
ret.f_[6] = 0.0f;
|
||||
ret.f_[10] = fCosine;
|
||||
ret.f_[14] = 0.0f;
|
||||
ret.f_[3] = 0.0f;
|
||||
ret.f_[7] = 0.0f;
|
||||
ret.f_[11] = 0.0f;
|
||||
ret.f_[15] = 1.0f;
|
||||
return ret;
|
||||
|
||||
}
|
||||
|
||||
Mat4 Mat4::RotationZ( const float fAngle )
|
||||
{
|
||||
Mat4 ret;
|
||||
float fCosine, fSine;
|
||||
|
||||
fCosine = cosf( fAngle );
|
||||
fSine = sinf( fAngle );
|
||||
|
||||
ret.f_[0] = fCosine;
|
||||
ret.f_[4] = fSine;
|
||||
ret.f_[8] = 0.0f;
|
||||
ret.f_[12] = 0.0f;
|
||||
ret.f_[1] = -fSine;
|
||||
ret.f_[5] = fCosine;
|
||||
ret.f_[9] = 0.0f;
|
||||
ret.f_[13] = 0.0f;
|
||||
ret.f_[2] = 0.0f;
|
||||
ret.f_[6] = 0.0f;
|
||||
ret.f_[10] = 1.0f;
|
||||
ret.f_[14] = 0.0f;
|
||||
ret.f_[3] = 0.0f;
|
||||
ret.f_[7] = 0.0f;
|
||||
ret.f_[11] = 0.0f;
|
||||
ret.f_[15] = 1.0f;
|
||||
return ret;
|
||||
}
|
||||
|
||||
Mat4 Mat4::Translation( const float fX, const float fY, const float fZ )
|
||||
{
|
||||
Mat4 ret;
|
||||
ret.f_[0] = 1.0f;
|
||||
ret.f_[4] = 0.0f;
|
||||
ret.f_[8] = 0.0f;
|
||||
ret.f_[12] = fX;
|
||||
ret.f_[1] = 0.0f;
|
||||
ret.f_[5] = 1.0f;
|
||||
ret.f_[9] = 0.0f;
|
||||
ret.f_[13] = fY;
|
||||
ret.f_[2] = 0.0f;
|
||||
ret.f_[6] = 0.0f;
|
||||
ret.f_[10] = 1.0f;
|
||||
ret.f_[14] = fZ;
|
||||
ret.f_[3] = 0.0f;
|
||||
ret.f_[7] = 0.0f;
|
||||
ret.f_[11] = 0.0f;
|
||||
ret.f_[15] = 1.0f;
|
||||
return ret;
|
||||
}
|
||||
|
||||
Mat4 Mat4::Translation( const Vec3 vec )
|
||||
{
|
||||
Mat4 ret;
|
||||
ret.f_[0] = 1.0f;
|
||||
ret.f_[4] = 0.0f;
|
||||
ret.f_[8] = 0.0f;
|
||||
ret.f_[12] = vec.x_;
|
||||
ret.f_[1] = 0.0f;
|
||||
ret.f_[5] = 1.0f;
|
||||
ret.f_[9] = 0.0f;
|
||||
ret.f_[13] = vec.y_;
|
||||
ret.f_[2] = 0.0f;
|
||||
ret.f_[6] = 0.0f;
|
||||
ret.f_[10] = 1.0f;
|
||||
ret.f_[14] = vec.z_;
|
||||
ret.f_[3] = 0.0f;
|
||||
ret.f_[7] = 0.0f;
|
||||
ret.f_[11] = 0.0f;
|
||||
ret.f_[15] = 1.0f;
|
||||
return ret;
|
||||
}
|
||||
|
||||
Mat4 Mat4::Perspective( float width, float height, float nearPlane, float farPlane )
|
||||
{
|
||||
float n2 = 2.0f * nearPlane;
|
||||
float rcpnmf = 1.f / (nearPlane - farPlane);
|
||||
|
||||
Mat4 result;
|
||||
result.f_[0] = n2 / width;
|
||||
result.f_[4] = 0;
|
||||
result.f_[8] = 0;
|
||||
result.f_[12] = 0;
|
||||
result.f_[1] = 0;
|
||||
result.f_[5] = n2 / height;
|
||||
result.f_[9] = 0;
|
||||
result.f_[13] = 0;
|
||||
result.f_[2] = 0;
|
||||
result.f_[6] = 0;
|
||||
result.f_[10] = (farPlane + nearPlane) * rcpnmf;
|
||||
result.f_[14] = farPlane * rcpnmf * n2;
|
||||
result.f_[3] = 0;
|
||||
result.f_[7] = 0;
|
||||
result.f_[11] = -1.0;
|
||||
result.f_[15] = 0;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
Mat4 Mat4::LookAt( const Vec3& vec_eye, const Vec3& vec_at, const Vec3& vec_up )
|
||||
{
|
||||
Vec3 vec_forward, vec_up_norm, vec_side;
|
||||
Mat4 result;
|
||||
|
||||
vec_forward.x_ = vec_eye.x_ - vec_at.x_;
|
||||
vec_forward.y_ = vec_eye.y_ - vec_at.y_;
|
||||
vec_forward.z_ = vec_eye.z_ - vec_at.z_;
|
||||
|
||||
vec_forward.Normalize();
|
||||
vec_up_norm = vec_up;
|
||||
vec_up_norm.Normalize();
|
||||
vec_side = vec_up_norm.Cross( vec_forward );
|
||||
vec_up_norm = vec_forward.Cross( vec_side );
|
||||
|
||||
result.f_[0] = vec_side.x_;
|
||||
result.f_[4] = vec_side.y_;
|
||||
result.f_[8] = vec_side.z_;
|
||||
result.f_[12] = 0;
|
||||
result.f_[1] = vec_up_norm.x_;
|
||||
result.f_[5] = vec_up_norm.y_;
|
||||
result.f_[9] = vec_up_norm.z_;
|
||||
result.f_[13] = 0;
|
||||
result.f_[2] = vec_forward.x_;
|
||||
result.f_[6] = vec_forward.y_;
|
||||
result.f_[10] = vec_forward.z_;
|
||||
result.f_[14] = 0;
|
||||
result.f_[3] = 0;
|
||||
result.f_[7] = 0;
|
||||
result.f_[11] = 0;
|
||||
result.f_[15] = 1.0;
|
||||
|
||||
result.PostTranslate( -vec_eye.x_, -vec_eye.y_, -vec_eye.z_ );
|
||||
return result;
|
||||
}
|
||||
|
||||
} //namespace ndkHelper
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user