Programação com OpenGL/Android GLUT Wrapper: diferenças entre revisões

 

Mesmo que o exemplo menciona a API versão <code>8</code>, colocaremos um <code>9</code>.

<uses-sdk android:minSdkVersion="9" />

Tambem, certifique-se que esteja assim seu manifest has:

<application ...

android:hasCode="true"

Caso contrário seu aplicativo não iniciará.

Seu ponto de entrada será a função <code>android_main</code>(em vez da mais comum que é <code>main</code> ou <code>WinMain</code>)

 

O empacotador é baseado no exemplo ''native-activity'', ele usa o código do 'android_native_app_glue' que ofereçe um processamento de eventos non-blocking.

<!-- Android.mk -->

LOCAL_STATIC_LIBRARIES := android_native_app_glue

...

$(call import-module,android/native_app_glue)

 

Desde que você não chame diretamente o código glue (seus pontos de entrada são os callbacks usados pelo Android, não o nosso), <code>android_native_app_glue.o</code> ele pode ser retirada pelo compilador, assim vamos chamar seus modelos de pontos de entrada:

// Certifique que o glue foi retirado.

app_dummy();

Ele usará o OpenGL ES 2.0 (em vez do exemplo em OpenGL Es 1.X):

<!-- Android.mk -->

LOCAL_LDLIBS := -llog -landroid -lEGL -lGLESv2

 

Para usar o GLM, nós precisaremos ativar o C++ STL:

<!-- Application.mk -->

APP_STL := gnustl_static

e mencionar o local aonde foi instalado:

<!-- Android.mk -->

LOCAL_CPPFLAGS := -I/usr/src/glm

 

Agora nós vamos declarar nossos arquivo fonte ( tut.cpp ):

<!-- Android.mk -->

LOCAL_SRC_FILES := main.c GL/glew.c tut.cpp

 

para rodar o compilador do sistema:

* Compile o Código em C/C++

ndk-build NDK_DEBUG=1 V=1

* Preparando o compilador Java do sistema (Somente uma vez):

android update project --name wikibooks-opengl --path . --target "android-10"

* Criando um pacote .apk:

ant debug

* E instalando:

ant installd

# ou manualmente:

adb install -r bin/wikibooks-opengl.apk

* Limpando:

ndk-build clean

ant clean

 

Nós incluiremos todos estes comandos no montador <code>Makefile</code>

 

Em primeiro lugar, solicitaremos os contextos disponíveis:

const EGLint attribs[] = {

...

...

eglChooseConfig(display, attribs, &config, 1, &numConfigs);

Depois criaremos o contexto:

static const EGLint ctx_attribs[] = {

EGL_CONTEXT_CLIENT_VERSION, 2,

};

context = eglCreateContext(display, config, EGL_NO_CONTEXT, ctx_attribs);

 

(Em Java:)

setEGLContextClientVersion(2);

// ou em um Renderizador personalizado:

int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };

EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);

 

É uma boa prática, mas não é obrigatória, que você de declare os requirementos OpenGL 2.0 no <code>AndroidManifest.xml</code>:

<uses-feature android:glEsVersion="0x00020000"></uses-feature>

<uses-sdk android:targetSdkVersion="9" android:minSdkVersion="9"></uses-sdk>

 

Quando o usuário vai para tela inicial(ou recebe uma chamada), seu aplicativo é pausado, Quando ele volta para o aplicativo, ele continua, mas o contexto OpenGL é perdido, Neste caso, você precisa recarregar todos recursos na GPU (VBOs, texturas e etc...), Existe um evento no Android para detectar se seu aplicativo foi "despausado".

 

Primeiro, nosso native activity trabalha com seu próprio segmento, então precisamos de cuidado ao recuperar o JNI handle em <code>android_main</code>:

JNIEnv* env = state_param->activity->env;

JavaVM* vm = state_param->activity->vm;

vm->AttachCurrentThread(&env, NULL);

 

Então vamos pegar o estado em nossa chamada instanciada NativeActivity:

jclass activityClass = env->GetObjectClass(state_param->activity->clazz);

 

Então nós decidiremos aonde extrair os arquivos. Então usaremos um cache padrão de diretório:

// Get path to cache dir (/data/data/org.wikibooks.OpenGL/cache)

jmethodID getCacheDir = env->GetMethodID(activityClass, "getCacheDir", "()Ljava/io/File;");

chdir(app_dir);

env->ReleaseStringUTFChars(jpath, app_dir);

 

Nos agora vamos pegar o AssetManager NativeActivity:

#include <android/asset_manager.h>

jobject assetManager = state_param->activity->assetManager;

AAssetManager* mgr = AAssetManager_fromJava(env, assetManager);

 

Agora a extração é simples: navegaremos pelos arquivos e copiaremos para o disco um por um:

AAssetDir* assetDir = AAssetManager_openDir(mgr, "");

const char* filename = (const char*)NULL;

}

AAssetDir_close(assetDir);

 

Agora, todos os arquivos podem ser acessados usando um fopen/cout do aplicativo.

 

Pela opção:

<activity ...

android:screenOrientation="portrait"

Seu aplicativo pode trabalhar apenas no modo portrait, independente do seu dispositivo ou das formas. Isto não é recomendado mas é muito usado em alguns jogos.

 

O manuseador <code>onSurfaceChanged_native</code> no montador(wrapper) <code>android_app_NativeActivity.cpp</code> não parece criar

o evento<code>onNativeWindowResized</code> adequadamente na mudança de orientação, Então vamos monitora-lo regularmente:

/* glutMainLoop */

 

continue;

}

Agora nos podemos processar o evento:

static void onNativeWindowResized(ANativeActivity* activity, ANativeWindow* window) {

struct android_app* android_app = (struct android_app*)activity->instance;

android_app_write_cmd(android_app, APP_CMD_WINDOW_RESIZED);

}

 

Nota: é possivel processar pelo evento <code>APP_CMD_CONFIG_CHANGED</code>, mas isto só acontece depois que tela é redimensionada, isto é muito cedo para pegar o novo tamanho da tela.

 

O Android pode apenas detectar o nova resolução e depois da troca de buffer, então vamos abusar de outra hook(uma chamada própria no lugar da chamada do original sistema) para obter o evento de redimensionamento:

/* android_main */

state_param->activity->callbacks->onContentRectChanged = onContentRectChanged;

glutPostRedisplay();

}

 

== Eventos de entrada do dispositivo ==