YGGverse
/
xash3d-fwgs
mirror of https://github.com/YGGverse/xash3d-fwgs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

engine: partially remove legacy Android port, in preparation of new port merge

pull/2/head
Alibek Omarov 1 year ago
parent
ba039b8e71
commit
ef663a8790
8 changed files with 4 additions and 2021 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      common/backends.h
  2. 22
      common/defaults.h
  3. 6
      engine/client/input.c
  4. 993
      engine/platform/android/android.c
  5. 46
      engine/platform/android/android_priv.h
  6. 277
      engine/platform/android/snd_opensles.c
  7. 665
      engine/platform/android/vid_android.c
  8. 9
      engine/platform/platform.h

7
common/backends.h
Unescape View File

@ -18,21 +18,17 @@ GNU General Public License for more details.
// video backends (XASH_VIDEO) // video backends (XASH_VIDEO)
#define VIDEO_NULL 0 #define VIDEO_NULL 0
#define VIDEO_SDL 1 #define VIDEO_SDL 1
#define VIDEO_ANDROID 2
#define VIDEO_FBDEV 3 #define VIDEO_FBDEV 3
#define VIDEO_DOS 4 #define VIDEO_DOS 4
// audio backends (XASH_SOUND) // audio backends (XASH_SOUND)
#define SOUND_NULL 0 #define SOUND_NULL 0
#define SOUND_SDL 1 #define SOUND_SDL 1
#define SOUND_OPENSLES 2
#define SOUND_ALSA 3 #define SOUND_ALSA 3
// input (XASH_INPUT) // input (XASH_INPUT)
#define INPUT_NULL 0 #define INPUT_NULL 0
#define INPUT_SDL 1 #define INPUT_SDL 1
#define INPUT_ANDROID 2
#define INPUT_EVDEV 3 #define INPUT_EVDEV 3
// timer (XASH_TIMER) // timer (XASH_TIMER)
@ -45,16 +41,13 @@ GNU General Public License for more details.
// messageboxes (XASH_MESSAGEBOX) // messageboxes (XASH_MESSAGEBOX)
#define MSGBOX_STDERR 0 #define MSGBOX_STDERR 0
#define MSGBOX_SDL 1 #define MSGBOX_SDL 1
#define MSGBOX_ANDROID 2
#define MSGBOX_WIN32 3 #define MSGBOX_WIN32 3
#define MSGBOX_NSWITCH 4 #define MSGBOX_NSWITCH 4
// library loading (XASH_LIB) // library loading (XASH_LIB)
#define LIB_NULL 0 #define LIB_NULL 0
#define LIB_POSIX 1 #define LIB_POSIX 1
#define LIB_WIN32 2 #define LIB_WIN32 2
#define LIB_STATIC 3 #define LIB_STATIC 3
#endif /* BACKENDS_H */ #endif /* BACKENDS_H */

22
common/defaults.h
Unescape View File

@ -52,26 +52,6 @@ SETUP BACKENDS DEFINITIONS
#endif #endif
#endif // XASH_MESSAGEBOX #endif // XASH_MESSAGEBOX
#endif #endif
#elif XASH_ANDROID
// we are building for Android platform, use Android APIs
#ifndef XASH_VIDEO
#define XASH_VIDEO VIDEO_ANDROID
#endif // XASH_VIDEO
#ifndef XASH_INPUT
#define XASH_INPUT INPUT_ANDROID
#endif // XASH_INPUT
#ifndef XASH_SOUND
#define XASH_SOUND SOUND_OPENSLES
#endif // XASH_SOUND
#ifndef XASH_MESSAGEBOX
#define XASH_MESSAGEBOX MSGBOX_ANDROID
#endif // XASH_MESSAGEBOX
#define XASH_USE_EVDEV 1
#define XASH_DYNAMIC_DLADDR
#elif XASH_LINUX #elif XASH_LINUX
// we are building for Linux without SDL2, can draw only to framebuffer yet // we are building for Linux without SDL2, can draw only to framebuffer yet
#ifndef XASH_VIDEO #ifndef XASH_VIDEO
@ -171,6 +151,8 @@ Default build-depended cvar and constant values
#define DEFAULT_MODE_WIDTH 960 #define DEFAULT_MODE_WIDTH 960
#define DEFAULT_MODE_HEIGHT 544 #define DEFAULT_MODE_HEIGHT 544
#define DEFAULT_ALLOWCONSOLE 1 #define DEFAULT_ALLOWCONSOLE 1
#elif XASH_ANDROID
#define DEFAULT_TOUCH_ENABLE "1"
#elif XASH_MOBILE_PLATFORM #elif XASH_MOBILE_PLATFORM
#define DEFAULT_TOUCH_ENABLE "1" #define DEFAULT_TOUCH_ENABLE "1"
#define DEFAULT_M_IGNORE "1" #define DEFAULT_M_IGNORE "1"

6
engine/client/input.c
Unescape View File

@ -179,9 +179,6 @@ void IN_ToggleClientMouse( int newstate, int oldstate )
{ {
Platform_SetCursorType( dc_arrow ); Platform_SetCursorType( dc_arrow );
#if XASH_ANDROID
Android_ShowMouse( true );
#endif
#if XASH_USE_EVDEV #if XASH_USE_EVDEV
Evdev_SetGrab( false ); Evdev_SetGrab( false );
#endif #endif
@ -190,9 +187,6 @@ void IN_ToggleClientMouse( int newstate, int oldstate )
{ {
Platform_SetCursorType( dc_none ); Platform_SetCursorType( dc_none );
#if XASH_ANDROID
Android_ShowMouse( false );
#endif
#if XASH_USE_EVDEV #if XASH_USE_EVDEV
Evdev_SetGrab( true ); Evdev_SetGrab( true );
#endif #endif

993
engine/platform/android/android.c
Unescape View File

@ -1,993 +0,0 @@
/*
android_nosdl.c - android backend
Copyright (C) 2016-2019 mittorn
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/
#include "platform/platform.h"
#if !defined(XASH_DEDICATED)
#include "input.h"
#include "client.h"
#include "sound.h"
#include "platform/android/android_priv.h"
#include "errno.h"
#include <pthread.h>
#include <sys/prctl.h>
#ifndef JNICALL
#define JNICALL // a1ba: workaround for my IDE, where Java files are not included
#define JNIEXPORT
#endif
convar_t *android_sleep;
static const int s_android_scantokey[] =
{
0, K_LEFTARROW, K_RIGHTARROW, K_AUX26, K_ESCAPE, // 0
K_AUX26, K_AUX25, '0', '1', '2', // 5
'3', '4', '5', '6', '7', // 10
'8', '9', '*', '#', K_UPARROW, // 15
K_DOWNARROW, K_LEFTARROW, K_RIGHTARROW, K_ENTER, K_AUX32, // 20
K_AUX31, K_AUX29, K_AUX28, K_AUX27, 'a', // 25
'b', 'c', 'd', 'e', 'f', // 30
'g', 'h', 'i', 'j', 'k', // 35
'l', 'm', 'n', 'o', 'p', // 40
'q', 'r', 's', 't', 'u', // 45
'v', 'w', 'x', 'y', 'z', // 50
',', '.', K_ALT, K_ALT, K_SHIFT, // 55
K_SHIFT, K_TAB, K_SPACE, 0, 0, // 60
0, K_ENTER, K_BACKSPACE, '`', '-', // 65
'=', '[', ']', '\\', ';', // 70
'\'', '/', '@', K_KP_NUMLOCK, 0, // 75
0, '+', '`', 0, 0, // 80
0, 0, 0, 0, 0, // 85
0, 0, K_PGUP, K_PGDN, 0, // 90
0, K_AUX1, K_AUX2, K_AUX14, K_AUX3, // 95
K_AUX4, K_AUX15, K_AUX6, K_AUX7, K_JOY1, // 100
K_JOY2, K_AUX10, K_AUX11, K_ESCAPE, K_ESCAPE, // 105
0, K_ESCAPE, K_DEL, K_CTRL, K_CTRL, // 110
K_CAPSLOCK, 0, 0, 0, 0, // 115
0, K_PAUSE, K_HOME, K_END, K_INS, // 120
0, 0, 0, 0, 0, // 125
0, K_F1, K_F2, K_F3, K_F4, // 130
K_F5, K_F6, K_F7, K_F8, K_F9, // 135
K_F10, K_F11, K_F12, K_KP_NUMLOCK, K_KP_INS, // 140
K_KP_END, K_KP_DOWNARROW, K_KP_PGDN, K_KP_LEFTARROW, K_KP_5, // 145
K_KP_RIGHTARROW,K_KP_HOME, K_KP_UPARROW, K_KP_PGUP, K_KP_SLASH, // 150
0, K_KP_MINUS, K_KP_PLUS, K_KP_DEL, ',', // 155
K_KP_ENTER, '=', '(', ')'
};
#define ANDROID_MAX_EVENTS 64
#define MAX_FINGERS 10
typedef enum event_type
{
event_touch_down = 0,
event_touch_up,
event_touch_move, // compatible with touchEventType
event_key_down,
event_key_up,
event_set_pause,
event_resize,
event_joyhat,
event_joyball,
event_joybutton,
event_joyaxis,
event_joyadd,
event_joyremove,
event_onpause,
event_ondestroy,
event_onresume,
event_onfocuschange,
} eventtype_t;
typedef struct touchevent_s
{
float x;
float y;
float dx;
float dy;
} touchevent_t;
typedef struct joyball_s
{
short xrel;
short yrel;
byte ball;
} joyball_t;
typedef struct joyhat_s
{
byte hat;
byte key;
} joyhat_t;
typedef struct joyaxis_s
{
short val;
byte axis;
} joyaxis_t;
typedef struct joybutton_s
{
int down;
byte button;
} joybutton_t;
typedef struct keyevent_s
{
int code;
} keyevent_t;
typedef struct event_s
{
eventtype_t type;
int arg;
union
{
touchevent_t touch;
joyhat_t hat;
joyball_t ball;
joyaxis_t axis;
joybutton_t button;
keyevent_t key;
};
} event_t;
typedef struct finger_s
{
float x, y;
qboolean down;
} finger_t;
static struct {
pthread_mutex_t mutex; // this mutex is locked while not running frame, used for events synchronization
pthread_mutex_t framemutex; // this mutex is locked while engine is running and unlocked while it reading events, used for pause in background.
event_t queue[ANDROID_MAX_EVENTS];
volatile int count;
finger_t fingers[MAX_FINGERS];
char inputtext[256];
float mousex, mousey;
} events = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER };
struct jnimethods_s jni;
struct jnimouse_s jnimouse;
#define Android_Lock() pthread_mutex_lock(&events.mutex);
#define Android_Unlock() pthread_mutex_unlock(&events.mutex);
#define Android_PushEvent() Android_Unlock()
typedef void (*pfnChangeGame)( const char *progname );
int EXPORT Host_Main( int argc, char **argv, const char *progname, int bChangeGame, pfnChangeGame func );
/*
========================
Android_AllocEvent
Lock event queue and return pointer to next event.
Caller must do Android_PushEvent() to unlock queue after setting parameters.
========================
*/
event_t *Android_AllocEvent( void )
{
Android_Lock();
if( events.count == ANDROID_MAX_EVENTS )
{
events.count--; //override last event
__android_log_print( ANDROID_LOG_ERROR, "Xash", "Too many events!!!" );
}
return &events.queue[ events.count++ ];
}
/*
=====================================================
JNI callbacks
On application start, setenv and onNativeResize called from
ui thread to set up engine configuration
nativeInit called directly from engine thread and will not return until exit.
These functions may be called from other threads at any time:
nativeKey
nativeTouch
onNativeResize
nativeString
nativeSetPause
=====================================================
*/
#define VA_ARGS(...) , ##__VA_ARGS__ // GCC extension
#define DECLARE_JNI_INTERFACE( ret, name, ... ) \
JNIEXPORT ret JNICALL Java_su_xash_engine_XashActivity_##name( JNIEnv *env, jclass clazz VA_ARGS(__VA_ARGS__) )
DECLARE_JNI_INTERFACE( int, nativeInit, jobject array )
{
int i;
int argc;
int status;
/* Prepare the arguments. */
int len = (*env)->GetArrayLength(env, array);
char** argv = calloc( 1 + len + 1, sizeof( char ** ));
argc = 0;
argv[argc++] = strdup("app_process");
for (i = 0; i < len; ++i) {
const char* utf;
char* arg = NULL;
jstring string = (*env)->GetObjectArrayElement(env, array, i);
if (string) {
utf = (*env)->GetStringUTFChars(env, string, 0);
if (utf) {
arg = strdup(utf);
(*env)->ReleaseStringUTFChars(env, string, utf);
}
(*env)->DeleteLocalRef(env, string);
}
if (!arg) {
arg = strdup("");
}
argv[argc++] = arg;
}
argv[argc] = NULL;
prctl(PR_SET_DUMPABLE, 1);
/* Init callbacks. */
jni.env = env;
jni.actcls = (*env)->FindClass(env, "su/xash/engine/XashActivity");
jni.enableTextInput = (*env)->GetStaticMethodID(env, jni.actcls, "showKeyboard", "(I)V");
jni.vibrate = (*env)->GetStaticMethodID(env, jni.actcls, "vibrate", "(I)V" );
jni.messageBox = (*env)->GetStaticMethodID(env, jni.actcls, "messageBox", "(Ljava/lang/String;Ljava/lang/String;)V");
jni.notify = (*env)->GetStaticMethodID(env, jni.actcls, "engineThreadNotify", "()V");
jni.setTitle = (*env)->GetStaticMethodID(env, jni.actcls, "setTitle", "(Ljava/lang/String;)V");
jni.setIcon = (*env)->GetStaticMethodID(env, jni.actcls, "setIcon", "(Ljava/lang/String;)V");
jni.getAndroidId = (*env)->GetStaticMethodID(env, jni.actcls, "getAndroidID", "()Ljava/lang/String;");
jni.saveID = (*env)->GetStaticMethodID(env, jni.actcls, "saveID", "(Ljava/lang/String;)V");
jni.loadID = (*env)->GetStaticMethodID(env, jni.actcls, "loadID", "()Ljava/lang/String;");
jni.showMouse = (*env)->GetStaticMethodID(env, jni.actcls, "showMouse", "(I)V");
jni.shellExecute = (*env)->GetStaticMethodID(env, jni.actcls, "shellExecute", "(Ljava/lang/String;)V");
jni.swapBuffers = (*env)->GetStaticMethodID(env, jni.actcls, "swapBuffers", "()V");
jni.toggleEGL = (*env)->GetStaticMethodID(env, jni.actcls, "toggleEGL", "(I)V");
jni.createGLContext = (*env)->GetStaticMethodID(env, jni.actcls, "createGLContext", "([I[I)Z");
jni.getGLAttribute = (*env)->GetStaticMethodID(env, jni.actcls, "getGLAttribute", "(I)I");
jni.deleteGLContext = (*env)->GetStaticMethodID(env, jni.actcls, "deleteGLContext", "()Z");
jni.getSelectedPixelFormat = (*env)->GetStaticMethodID(env, jni.actcls, "getSelectedPixelFormat", "()I");
jni.getSurface = (*env)->GetStaticMethodID(env, jni.actcls, "getNativeSurface", "()Landroid/view/Surface;");
/* Run the application. */
status = Host_Main( argc, argv, getenv("XASH3D_GAMEDIR"), false, NULL );
/* Release the arguments. */
for (i = 0; i < argc; ++i)
free(argv[i]);
free(argv);
return status;
}
DECLARE_JNI_INTERFACE( void, onNativeResize, jint width, jint height )
{
event_t *event;
if( !width || !height )
return;
jni.width=width, jni.height=height;
// alloc update event to change screen size
event = Android_AllocEvent();
event->type = event_resize;
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( void, nativeQuit )
{
}
DECLARE_JNI_INTERFACE( void, nativeSetPause, jint pause )
{
event_t *event = Android_AllocEvent();
event->type = event_set_pause;
event->arg = pause;
Android_PushEvent();
// if pause enabled, hold engine by locking frame mutex.
// Engine will stop after event reading and will not continue untill unlock
if( android_sleep && android_sleep->value )
{
if( pause )
pthread_mutex_lock( &events.framemutex );
else
pthread_mutex_unlock( &events.framemutex );
}
}
DECLARE_JNI_INTERFACE( void, nativeUnPause )
{
// UnPause engine before sending critical events
if( android_sleep && android_sleep->value )
pthread_mutex_unlock( &events.framemutex );
}
DECLARE_JNI_INTERFACE( void, nativeKey, jint down, jint code )
{
event_t *event;
if( code < 0 )
{
event = Android_AllocEvent();
event->arg = (-code) & 255;
event->type = down?event_key_down:event_key_up;
Android_PushEvent();
}
else
{
if( code >= ( sizeof( s_android_scantokey ) / sizeof( s_android_scantokey[0] ) ) )
{
Con_DPrintf( "nativeKey: unknown Android key %d\n", code );
return;
}
if( !s_android_scantokey[code] )
{
Con_DPrintf( "nativeKey: unmapped Android key %d\n", code );
return;
}
event = Android_AllocEvent();
event->type = down?event_key_down:event_key_up;
event->arg = s_android_scantokey[code];
Android_PushEvent();
}
}
DECLARE_JNI_INTERFACE( void, nativeString, jobject string )
{
char* str = (char *) (*env)->GetStringUTFChars(env, string, NULL);
Android_Lock();
strncat( events.inputtext, str, 256 );
Android_Unlock();
(*env)->ReleaseStringUTFChars(env, string, str);
}
#ifdef SOFTFP_LINK
DECLARE_JNI_INTERFACE( void, nativeTouch, jint finger, jint action, jfloat x, jfloat y ) __attribute__((pcs("aapcs")));
#endif
DECLARE_JNI_INTERFACE( void, nativeTouch, jint finger, jint action, jfloat x, jfloat y )
{
float dx, dy;
event_t *event;
// if something wrong with android event
if( finger > MAX_FINGERS )
return;
// not touch action?
if( !( action >=0 && action <= 2 ) )
return;
// 0.0f .. 1.0f
x /= jni.width;
y /= jni.height;
if( action )
dx = x - events.fingers[finger].x, dy = y - events.fingers[finger].y;
else
dx = dy = 0.0f;
events.fingers[finger].x = x, events.fingers[finger].y = y;
// check if we should skip some events
if( ( action == 2 ) && ( !dx && !dy ) )
return;
if( ( action == 0 ) && events.fingers[finger].down )
return;
if( ( action == 1 ) && !events.fingers[finger].down )
return;
if( action == 2 && !events.fingers[finger].down )
action = 0;
if( action == 0 )
events.fingers[finger].down = true;
else if( action == 1 )
events.fingers[finger].down = false;
event = Android_AllocEvent();
event->arg = finger;
event->type = action;
event->touch.x = x;
event->touch.y = y;
event->touch.dx = dx;
event->touch.dy = dy;
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( void, nativeBall, jint id, jbyte ball, jshort xrel, jshort yrel )
{
event_t *event = Android_AllocEvent();
event->type = event_joyball;
event->arg = id;
event->ball.ball = ball;
event->ball.xrel = xrel;
event->ball.yrel = yrel;
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( void, nativeHat, jint id, jbyte hat, jbyte key, jboolean down )
{
event_t *event = Android_AllocEvent();
static byte engineKeys;
if( !key )
engineKeys = 0; // centered;
if( down )
engineKeys |= key;
else
engineKeys &= ~key;
event->type = event_joyhat;
event->arg = id;
event->hat.hat = hat;
event->hat.key = engineKeys;
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( void, nativeAxis, jint id, jbyte axis, jshort val )
{
event_t *event = Android_AllocEvent();
event->type = event_joyaxis;
event->arg = id;
event->axis.axis = axis;
event->axis.val = val;
__android_log_print(ANDROID_LOG_VERBOSE, "Xash", "axis %i %i", axis, val );
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( void, nativeJoyButton, jint id, jbyte button, jboolean down )
{
event_t *event = Android_AllocEvent();
event->type = event_joybutton;
event->arg = id;
event->button.button = button;
event->button.down = down;
__android_log_print(ANDROID_LOG_VERBOSE, "Xash", "button %i", button );
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( void, nativeJoyAdd, jint id )
{
event_t *event = Android_AllocEvent();
event->type = event_joyadd;
event->arg = id;
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( void, nativeJoyDel, jint id )
{
event_t *event = Android_AllocEvent();
event->type = event_joyremove;
event->arg = id;
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( void, nativeOnResume )
{
event_t *event = Android_AllocEvent();
event->type = event_onresume;
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( void, nativeOnFocusChange )
{
event_t *event = Android_AllocEvent();
event->type = event_onfocuschange;
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( void, nativeOnPause )
{
event_t *event = Android_AllocEvent();
event->type = event_onpause;
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( void, nativeOnDestroy )
{
event_t *event = Android_AllocEvent();
event->type = event_ondestroy;
Android_PushEvent();
}
DECLARE_JNI_INTERFACE( int, setenv, jstring key, jstring value, jboolean overwrite )
{
char* k = (char *) (*env)->GetStringUTFChars(env, key, NULL);
char* v = (char *) (*env)->GetStringUTFChars(env, value, NULL);
int err = setenv(k, v, overwrite);
(*env)->ReleaseStringUTFChars(env, key, k);
(*env)->ReleaseStringUTFChars(env, value, v);
return err;
}
DECLARE_JNI_INTERFACE( void, nativeMouseMove, jfloat x, jfloat y )
{
Android_Lock();
events.mousex += x;
events.mousey += y;
Android_Unlock();
}
DECLARE_JNI_INTERFACE( int, nativeTestWritePermission, jstring jPath )
{
char *path = (char *)(*env)->GetStringUTFChars(env, jPath, NULL);
FILE *fd;
char testFile[PATH_MAX];
int ret = 0;
// maybe generate new file everytime?
Q_snprintf( testFile, PATH_MAX, "%s/.testfile", path );
__android_log_print( ANDROID_LOG_VERBOSE, "Xash", "nativeTestWritePermission: file=%s", testFile );
fd = fopen( testFile, "w+" );
if( fd )
{
__android_log_print( ANDROID_LOG_VERBOSE, "Xash", "nativeTestWritePermission: passed" );
ret = 1;
fclose( fd );
remove( testFile );
}
else
{
__android_log_print( ANDROID_LOG_VERBOSE, "Xash", "nativeTestWritePermission: error=%s", strerror( errno ) );
}
(*env)->ReleaseStringUTFChars( env, jPath, path );
return ret;
}
JNIEXPORT jint JNICALL JNI_OnLoad( JavaVM *vm, void *reserved )
{
return JNI_VERSION_1_6;
}
/*
========================
Platform_Init
Initialize android-related cvars
========================
*/
void Platform_Init( void )
{
android_sleep = Cvar_Get( "android_sleep", "1", FCVAR_ARCHIVE, "Enable sleep in background" );
}
void Platform_Shutdown( void )
{
}
/*
========================
Android_EnableTextInput
Show virtual keyboard
========================
*/
void Platform_EnableTextInput( qboolean enable )
{
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.enableTextInput, enable );
}
/*
========================
Android_Vibrate
========================
*/
void Platform_Vibrate( float life, char flags )
{
if( life )
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.vibrate, (int)life );
}
/*
========================
Android_GetNativeObject
========================
*/
void *Platform_GetNativeObject( const char *objName )
{
static const char *availObjects[] = { "JNIEnv", "ActivityClass", NULL };
void *object = NULL;
if( !objName )
{
object = (void*)availObjects;
}
else if( !strcasecmp( objName, "JNIEnv" ) )
{
object = (void*)jni.env;
}
else if( !strcasecmp( objName, "ActivityClass" ) )
{
object = (void*)jni.actcls;
}
return object;
}
/*
========================
Android_MessageBox
Show messagebox and wait for OK button press
========================
*/
#if XASH_MESSAGEBOX == MSGBOX_ANDROID
void Platform_MessageBox( const char *title, const char *text, qboolean parentMainWindow )
{
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.messageBox, (*jni.env)->NewStringUTF( jni.env, title ), (*jni.env)->NewStringUTF( jni.env ,text ) );
}
#endif // XASH_MESSAGEBOX == MSGBOX_ANDROID
/*
========================
Android_GetAndroidID
========================
*/
const char *Android_GetAndroidID( void )
{
static char id[65];
const char *resultCStr;
jstring resultJNIStr;
if( id[0] )
return id;
resultJNIStr = (jstring)(*jni.env)->CallStaticObjectMethod( jni.env, jni.actcls, jni.getAndroidId );
resultCStr = (*jni.env)->GetStringUTFChars( jni.env, resultJNIStr, NULL );
Q_strncpy( id, resultCStr, 64 );
(*jni.env)->ReleaseStringUTFChars( jni.env, resultJNIStr, resultCStr );
if( !id[0] )
return NULL;
return id;
}
/*
========================
Android_LoadID
========================
*/
const char *Android_LoadID( void )
{
static char id[65];
jstring resultJNIStr = (jstring)(*jni.env)->CallStaticObjectMethod( jni.env, jni.actcls, jni.loadID );
const char *resultCStr = (*jni.env)->GetStringUTFChars( jni.env, resultJNIStr, NULL );
Q_strncpy( id, resultCStr, 64 );
(*jni.env)->ReleaseStringUTFChars( jni.env, resultJNIStr, resultCStr );
return id;
}
/*
========================
Android_SaveID
========================
*/
void Android_SaveID( const char *id )
{
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.saveID, (*jni.env)->NewStringUTF( jni.env, id ) );
}
/*
========================
Android_MouseMove
========================
*/
void Platform_MouseMove( float *x, float *y )
{
*x = jnimouse.x;
*y = jnimouse.y;
jnimouse.x = 0;
jnimouse.y = 0;
// Con_Reportf( "Android_MouseMove: %f %f\n", *x, *y );
}
/*
========================
Android_AddMove
========================
*/
void Android_AddMove( float x, float y )
{
jnimouse.x += x;
jnimouse.y += y;
}
void GAME_EXPORT Platform_GetMousePos( int *x, int *y )
{
// stub
}
void GAME_EXPORT Platform_SetMousePos( int x, int y )
{
// stub
}
int Platform_JoyInit( int numjoy )
{
// stub
return 0;
}
/*
========================
Android_ShowMouse
========================
*/
void Android_ShowMouse( qboolean show )
{
if( m_ignore->value )
show = true;
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.showMouse, show );
}
/*
========================
Android_ShellExecute
========================
*/
void Platform_ShellExecute( const char *path, const char *parms )
{
jstring jstr;
if( !path )
return; // useless
// get java.lang.String
jstr = (*jni.env)->NewStringUTF( jni.env, path );
// open browser
(*jni.env)->CallStaticVoidMethod(jni.env, jni.actcls, jni.shellExecute, jstr);
// no need to free jstr
}
int Platform_GetClipboardText( char *buffer, size_t size )
{
// stub
if( size ) buffer[0] = 0;
return 0;
}
void Platform_SetClipboardText( const char *buffer )
{
// stub
}
void Platform_SetCursorType( VGUI_DefaultCursor cursor )
{
// stub
}
key_modifier_t Platform_GetKeyModifiers( void )
{
// stub
return KeyModifier_None;
}
void Platform_PreCreateMove( void )
{
// stub
}
/*
========================
Android_RunEvents
Execute all events from queue
========================
*/
void Platform_RunEvents( void )
{
int i;
// enter events read
Android_Lock();
pthread_mutex_unlock( &events.framemutex );
for( i = 0; i < events.count; i++ )
{
switch( events.queue[i].type )
{
case event_touch_down:
case event_touch_up:
case event_touch_move:
IN_TouchEvent( (touchEventType)events.queue[i].type, events.queue[i].arg,
events.queue[i].touch.x, events.queue[i].touch.y,
events.queue[i].touch.dx, events.queue[i].touch.dy );
break;
case event_key_down:
Key_Event( events.queue[i].arg, true );
if( events.queue[i].arg == K_AUX31 || events.queue[i].arg == K_AUX29 )
{
host.force_draw_version = true;
host.force_draw_version_time = host.realtime + FORCE_DRAW_VERSION_TIME;
}
break;
case event_key_up:
Key_Event( events.queue[i].arg, false );
if( events.queue[i].arg == K_AUX31 || events.queue[i].arg == K_AUX29 )
{
host.force_draw_version = true;
host.force_draw_version_time = host.realtime + FORCE_DRAW_VERSION_TIME;
}
break;
case event_set_pause:
// destroy EGL surface when hiding application
if( !events.queue[i].arg )
{
SNDDMA_Activate( true );
// (*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.toggleEGL, 1 );
Android_UpdateSurface( true );
host.status = HOST_FRAME;
SetBits( gl_vsync->flags, FCVAR_CHANGED ); // set swap interval
host.force_draw_version = true;
host.force_draw_version_time = host.realtime + FORCE_DRAW_VERSION_TIME;
}
if( events.queue[i].arg )
{
SNDDMA_Activate( false );
Android_UpdateSurface( false );
host.status = HOST_NOFOCUS;
// (*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.toggleEGL, 0 );
}
break;
case event_resize:
// reinitialize EGL and change engine screen size
if( host.status == HOST_FRAME &&( refState.width != jni.width || refState.height != jni.height ) )
{
// (*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.toggleEGL, 0 );
// (*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.toggleEGL, 1 );
Android_UpdateSurface( true );
SetBits( gl_vsync->flags, FCVAR_CHANGED ); // set swap interval
VID_SetMode();
}
break;
case event_joyadd:
Joy_AddEvent();
break;
case event_joyremove:
Joy_RemoveEvent();
break;
case event_joyball:
if( !Joy_IsActive() )
Joy_AddEvent();
Joy_BallMotionEvent( events.queue[i].ball.ball,
events.queue[i].ball.xrel, events.queue[i].ball.yrel );
break;
case event_joyhat:
if( !Joy_IsActive() )
Joy_AddEvent();
Joy_HatMotionEvent( events.queue[i].hat.hat, events.queue[i].hat.key );
break;
case event_joyaxis:
if( !Joy_IsActive() )
Joy_AddEvent();
Joy_AxisMotionEvent( events.queue[i].axis.axis, events.queue[i].axis.val );
break;
case event_joybutton:
if( !Joy_IsActive() )
Joy_AddEvent();
Joy_ButtonEvent( events.queue[i].button.button, (byte)events.queue[i].button.down );
break;
case event_ondestroy:
//host.skip_configs = true; // skip config save, because engine may be killed during config save
Sys_Quit();
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.notify );
break;
case event_onpause:
#ifdef PARANOID_CONFIG_SAVE
switch( host.status )
{
case HOST_INIT:
case HOST_CRASHED:
case HOST_ERR_FATAL:
Con_Reportf( S_WARN "Abnormal host state during onPause (%d), skipping config save!\n", host.status );
break;
default:
// restore all latched cheat cvars
Cvar_SetCheatState( true );
Host_WriteConfig();
}
#endif
// disable sound during call/screen-off
SNDDMA_Activate( false );
// host.status = HOST_NOFOCUS;
// stop blocking UI thread
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.notify );
break;
case event_onresume:
// re-enable sound after onPause
// host.status = HOST_FRAME;
SNDDMA_Activate( true );
host.force_draw_version = true;
host.force_draw_version_time = host.realtime + FORCE_DRAW_VERSION_TIME;
break;
case event_onfocuschange:
host.force_draw_version = true;
host.force_draw_version_time = host.realtime + FORCE_DRAW_VERSION_TIME;
break;
}
}
events.count = 0; // no more events
// text input handled separately to allow unicode symbols
for( i = 0; events.inputtext[i]; i++ )
{
int ch;
// if engine does not use utf-8, we need to convert it to preferred encoding
if( !Q_stricmp( cl_charset->string, "utf-8" ) )
ch = (unsigned char)events.inputtext[i];
else
ch = Con_UtfProcessCharForce( (unsigned char)events.inputtext[i] );
if( !ch ) // utf-8
continue;
// some keyboards may send enter as text
if( ch == '\n' )
{
Key_Event( K_ENTER, true );
Key_Event( K_ENTER, false );
continue;
}
// otherwise just push it by char, text render will decode unicode strings
CL_CharEvent( ch );
}
events.inputtext[0] = 0; // no more text
jnimouse.x += events.mousex;
events.mousex = 0;
jnimouse.y += events.mousey;
events.mousey = 0;
//end events read
Android_Unlock();
pthread_mutex_lock( &events.framemutex );
}
#endif // XASH_DEDICATED

46
engine/platform/android/android_priv.h
Unescape View File

@ -1,46 +0,0 @@
#pragma once
#ifndef ANDROID_PRIV_H
#define ANDROID_PRIV_H
#include <EGL/egl.h>
#include <android/log.h>
#include <jni.h>
extern struct jnimethods_s
{
jclass actcls;
JavaVM *vm;
JNIEnv *env;
jmethodID enableTextInput;
jmethodID vibrate;
jmethodID messageBox;
jmethodID notify;
jmethodID setTitle;
jmethodID setIcon;
jmethodID getAndroidId;
jmethodID saveID;
jmethodID loadID;
jmethodID showMouse;
jmethodID shellExecute;
jmethodID swapBuffers;
jmethodID toggleEGL;
jmethodID createGLContext;
jmethodID getGLAttribute;
jmethodID deleteGLContext;
jmethodID getSelectedPixelFormat;
jmethodID getSurface;
int width, height;
} jni;
extern struct jnimouse_s
{
float x, y;
} jnimouse;
//
// vid_android.c
//
void Android_UpdateSurface( qboolean active );
#endif // ANDROID_PRIV_H

277
engine/platform/android/snd_opensles.c
Unescape View File

@ -1,277 +0,0 @@
/*
Copyright (C) 2015 SiPlus, Chasseur de bots
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "common.h"
#include "platform/platform.h"
#if XASH_SOUND == SOUND_OPENSLES
#include <SLES/OpenSLES.h>
#include "pthread.h"
#include "sound.h"
extern dma_t dma;
static SLObjectItf snddma_android_engine = NULL;
static SLObjectItf snddma_android_outputMix = NULL;
static SLObjectItf snddma_android_player = NULL;
static SLBufferQueueItf snddma_android_bufferQueue;
static SLPlayItf snddma_android_play;
static pthread_mutex_t snddma_android_mutex = PTHREAD_MUTEX_INITIALIZER;
static int snddma_android_size;
static const SLInterfaceID *pSL_IID_ENGINE;
static const SLInterfaceID *pSL_IID_BUFFERQUEUE;
static const SLInterfaceID *pSL_IID_PLAY;
static SLresult SLAPIENTRY (*pslCreateEngine)(
SLObjectItf *pEngine,
SLuint32 numOptions,
const SLEngineOption *pEngineOptions,
SLuint32 numInterfaces,
const SLInterfaceID *pInterfaceIds,
const SLboolean * pInterfaceRequired
);
void SNDDMA_Activate( qboolean active )
{
if( !dma.initialized )
return;
if( active )
{
memset( dma.buffer, 0, snddma_android_size * 2 );
(*snddma_android_bufferQueue)->Enqueue( snddma_android_bufferQueue, dma.buffer, snddma_android_size );
(*snddma_android_play)->SetPlayState( snddma_android_play, SL_PLAYSTATE_PLAYING );
}
else
{
(*snddma_android_play)->SetPlayState( snddma_android_play, SL_PLAYSTATE_STOPPED );
(*snddma_android_bufferQueue)->Clear( snddma_android_bufferQueue );
}
}
static void SNDDMA_Android_Callback( SLBufferQueueItf bq, void *context )
{
uint8_t *buffer2;
pthread_mutex_lock( &snddma_android_mutex );
buffer2 = ( uint8_t * )dma.buffer + snddma_android_size;
(*bq)->Enqueue( bq, buffer2, snddma_android_size );
memcpy( buffer2, dma.buffer, snddma_android_size );
memset( dma.buffer, 0, snddma_android_size );
dma.samplepos += dma.samples;
pthread_mutex_unlock( &snddma_android_mutex );
}
static const char *SNDDMA_Android_Init( void )
{
SLresult result;
SLEngineItf engine;
int freq;
SLDataLocator_BufferQueue sourceLocator;
SLDataFormat_PCM sourceFormat;
SLDataSource source;
SLDataLocator_OutputMix sinkLocator;
SLDataSink sink;
SLInterfaceID interfaceID;
SLboolean interfaceRequired;
int samples;
void *handle = dlopen( "libOpenSLES.so", RTLD_LAZY );
if( !handle )
return "dlopen for libOpenSLES.so";
pslCreateEngine = dlsym( handle, "slCreateEngine" );
if( !pslCreateEngine )
return "resolve slCreateEngine";
pSL_IID_ENGINE = dlsym( handle, "SL_IID_ENGINE" );
if( !pSL_IID_ENGINE )
return "resolve SL_IID_ENGINE";
pSL_IID_PLAY = dlsym( handle, "SL_IID_PLAY" );
if( !pSL_IID_PLAY )
return "resolve SL_IID_PLAY";
pSL_IID_BUFFERQUEUE = dlsym( handle, "SL_IID_BUFFERQUEUE" );
if( !pSL_IID_BUFFERQUEUE )
return "resolve SL_IID_BUFFERQUEUE";
result = pslCreateEngine( &snddma_android_engine, 0, NULL, 0, NULL, NULL );
if( result != SL_RESULT_SUCCESS ) return "slCreateEngine";
result = (*snddma_android_engine)->Realize( snddma_android_engine, SL_BOOLEAN_FALSE );
if( result != SL_RESULT_SUCCESS ) return "engine->Realize";
result = (*snddma_android_engine)->GetInterface( snddma_android_engine, *pSL_IID_ENGINE, &engine );
if( result != SL_RESULT_SUCCESS ) return "engine->GetInterface(ENGINE)";
result = (*engine)->CreateOutputMix( engine, &snddma_android_outputMix, 0, NULL, NULL );
if( result != SL_RESULT_SUCCESS ) return "engine->CreateOutputMix";
result = (*snddma_android_outputMix)->Realize( snddma_android_outputMix, SL_BOOLEAN_FALSE );
if( result != SL_RESULT_SUCCESS ) return "outputMix->Realize";
freq = SOUND_DMA_SPEED;
sourceLocator.locatorType = SL_DATALOCATOR_BUFFERQUEUE;
sourceLocator.numBuffers = 2;
sourceFormat.formatType = SL_DATAFORMAT_PCM;
sourceFormat.numChannels = 2; // always stereo, because engine supports only stereo
sourceFormat.samplesPerSec = freq * 1000;
sourceFormat.bitsPerSample = 16; // always 16 bit audio
sourceFormat.containerSize = sourceFormat.bitsPerSample;
sourceFormat.channelMask = SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT;
sourceFormat.endianness = SL_BYTEORDER_LITTLEENDIAN;
source.pLocator = &sourceLocator;
source.pFormat = &sourceFormat;
sinkLocator.locatorType = SL_DATALOCATOR_OUTPUTMIX;
sinkLocator.outputMix = snddma_android_outputMix;
sink.pLocator = &sinkLocator;
sink.pFormat = NULL;
interfaceID = *pSL_IID_BUFFERQUEUE;
interfaceRequired = SL_BOOLEAN_TRUE;
result = (*engine)->CreateAudioPlayer( engine, &snddma_android_player, &source, &sink, 1, &interfaceID, &interfaceRequired );
if( result != SL_RESULT_SUCCESS ) return "engine->CreateAudioPlayer";
result = (*snddma_android_player)->Realize( snddma_android_player, SL_BOOLEAN_FALSE );
if( result != SL_RESULT_SUCCESS ) return "player->Realize";
result = (*snddma_android_player)->GetInterface( snddma_android_player, *pSL_IID_BUFFERQUEUE, &snddma_android_bufferQueue );
if( result != SL_RESULT_SUCCESS ) return "player->GetInterface(BUFFERQUEUE)";
result = (*snddma_android_player)->GetInterface( snddma_android_player, *pSL_IID_PLAY, &snddma_android_play );
if( result != SL_RESULT_SUCCESS ) return "player->GetInterface(PLAY)";
result = (*snddma_android_bufferQueue)->RegisterCallback( snddma_android_bufferQueue, SNDDMA_Android_Callback, NULL );
if( result != SL_RESULT_SUCCESS ) return "bufferQueue->RegisterCallback";
samples = s_samplecount.value;
if( !samples )
samples = 4096;
dma.format.channels = sourceFormat.numChannels;
dma.samples = samples * sourceFormat.numChannels;
dma.format.speed = freq;
snddma_android_size = dma.samples * ( sourceFormat.bitsPerSample >> 3 );
dma.buffer = Z_Malloc( snddma_android_size * 2 );
dma.samplepos = 0;
// dma.sampleframes = dma.samples / dma.format.channels;
dma.format.width = 2;
if( !dma.buffer ) return "malloc";
//snddma_android_mutex = trap_Mutex_Create();
dma.initialized = true;
SNDDMA_Activate( true );
return NULL;
}
qboolean SNDDMA_Init( void )
{
const char *initError;
Msg( "OpenSL ES audio device initializing...\n" );
initError = SNDDMA_Android_Init();
if( initError )
{
Msg( S_ERROR "SNDDMA_Init: %s failed.\n", initError );
SNDDMA_Shutdown();
return false;
}
Msg( "OpenSL ES audio initialized.\n" );
dma.backendName = "OpenSL ES";
return true;
}
void SNDDMA_Shutdown( void )
{
Msg( "Closing OpenSL ES audio device...\n" );
if( snddma_android_player )
{
(*snddma_android_player)->Destroy( snddma_android_player );
snddma_android_player = NULL;
}
if( snddma_android_outputMix )
{
(*snddma_android_outputMix)->Destroy( snddma_android_outputMix );
snddma_android_outputMix = NULL;
}
if( snddma_android_engine )
{
(*snddma_android_engine)->Destroy( snddma_android_engine );
snddma_android_engine = NULL;
}
if( dma.buffer )
{
Z_Free( dma.buffer );
dma.buffer = NULL;
}
//if( snddma_android_mutex )
//trap_Mutex_Destroy( &snddma_android_mutex );
Msg( "OpenSL ES audio device shut down.\n" );
}
void SNDDMA_Submit( void )
{
pthread_mutex_unlock( &snddma_android_mutex );
}
void SNDDMA_BeginPainting( void )
{
pthread_mutex_lock( &snddma_android_mutex );
}
qboolean VoiceCapture_Init( void )
{
return false;
}
qboolean VoiceCapture_Activate( qboolean activate )
{
return false;
}
qboolean VoiceCapture_Lock( qboolean lock )
{
return false;
}
void VoiceCapture_Shutdown( void )
{
}
#endif

665
engine/platform/android/vid_android.c
Unescape View File

@ -1,665 +0,0 @@
#include "platform/platform.h"
#include "input.h"
#include "client.h"
#include "filesystem.h"
#include "platform/android/android_priv.h"
#include "vid_common.h"
#include <android/native_window.h>
#include <android/native_window_jni.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
static struct vid_android_s
{
int gl_attribs[REF_GL_ATTRIBUTES_COUNT];
qboolean gl_attribs_set[REF_GL_ATTRIBUTES_COUNT];
EGLint gl_api;
qboolean gles1;
void *libgles1, *libgles2;
qboolean has_context;
ANativeWindow* window;
} vid_android;
static struct nw_s
{
void (*release)(ANativeWindow* window);
int32_t (*getWidth)(ANativeWindow* window);
int32_t (*getHeight)(ANativeWindow* window);
int32_t (*getFormat)(ANativeWindow* window);
int32_t (*setBuffersGeometry)(ANativeWindow* window, int32_t width, int32_t height, int32_t format);
int32_t (*lock)(ANativeWindow* window, ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds);
int32_t (*unlockAndPost)(ANativeWindow* window);
ANativeWindow* (*fromSurface)(JNIEnv* env, jobject surface);
} nw;
#define NW_FF(x) {"ANativeWindow_"#x, (void*)&nw.x}
static dllfunc_t android_funcs[] =
{
NW_FF(release),
NW_FF(getWidth),
NW_FF(getHeight),
NW_FF(getFormat),
NW_FF(setBuffersGeometry),
NW_FF(lock),
NW_FF(unlockAndPost),
NW_FF(fromSurface),
{ NULL, NULL }
};
#undef NW_FF
dll_info_t android_info = { "libandroid.so", android_funcs, false };
static struct egl_s
{
EGLSurface (*GetCurrentSurface)(EGLint readdraw);
EGLDisplay (*GetCurrentDisplay)(void);
EGLint (*GetError)(void);
EGLBoolean (*SwapBuffers)(EGLDisplay dpy, EGLSurface surface);
EGLBoolean (*SwapInterval)(EGLDisplay dpy, EGLint interval);
void *(*GetProcAddress)(const char *procname);
} egl;
#undef GetProcAddress
#define EGL_FF(x) {"egl"#x, (void*)&egl.x}
static dllfunc_t egl_funcs[] =
{
EGL_FF(SwapInterval),
EGL_FF(SwapBuffers),
EGL_FF(GetError),
EGL_FF(GetCurrentDisplay),
EGL_FF(GetCurrentSurface),
EGL_FF(GetProcAddress),
{ NULL, NULL }
};
#undef EGL_FF
dll_info_t egl_info = { "libEGL.so", egl_funcs, false };
static struct nativeegl_s
{
qboolean valid;
void *window;
EGLDisplay dpy;
EGLSurface surface;
EGLContext context;
EGLConfig cfg;
EGLint numCfg;
const char *extensions;
} negl;
/*
========================
Android_SwapInterval
========================
*/
static void Android_SwapInterval( int interval )
{
if( negl.valid )
egl.SwapInterval( negl.dpy, interval );
}
/*
========================
Android_SetTitle
========================
*/
static void Android_SetTitle( const char *title )
{
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.setTitle, (*jni.env)->NewStringUTF( jni.env, title ) );
}
/*
========================
Android_SetIcon
========================
*/
static void Android_SetIcon( const char *path )
{
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.setIcon, (*jni.env)->NewStringUTF( jni.env, path ) );
}
/*
========================
Android_GetScreenRes
Resolution got from last resize event
========================
*/
static void Android_GetScreenRes( int *width, int *height )
{
*width=jni.width, *height=jni.height;
}
/*
========================
Android_SwapBuffers
Update screen. Use native EGL if possible
========================
*/
void GL_SwapBuffers( void )
{
if( negl.valid )
{
egl.SwapBuffers( negl.dpy, negl.surface );
}
else
{
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.swapBuffers );
}
}
/*
========================
Android_UpdateSurface
Check if we may use native EGL without jni calls
========================
*/
void Android_UpdateSurface( qboolean active )
{
negl.valid = false;
if( nw.release )
{
if( vid_android.window && !active )
{
nw.release( vid_android.window );
vid_android.window = NULL;
}
if( active )
{
jobject surf;
if( vid_android.window )
nw.release( vid_android.window );
surf = (*jni.env)->CallStaticObjectMethod(jni.env, jni.actcls, jni.getSurface);
Con_Printf("s %p\n", surf);
vid_android.window = nw.fromSurface(jni.env, surf);
Con_Printf("w %p\n", vid_android.window);
nw.setBuffersGeometry(vid_android.window, 0, 0, WINDOW_FORMAT_RGB_565 );
(*jni.env)->DeleteLocalRef( jni.env, surf );
}
return;
}
if( !vid_android.has_context )
return;
if( ( active && host.status == HOST_FRAME ) || !active )
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.toggleEGL, 0 );
if( active )
(*jni.env)->CallStaticVoidMethod( jni.env, jni.actcls, jni.toggleEGL, 1 );
if( !Sys_CheckParm("-nativeegl") || !active )
return; // enabled by user
if( !egl.GetCurrentDisplay )
return;
negl.dpy = egl.GetCurrentDisplay();
if( negl.dpy == EGL_NO_DISPLAY )
return;
negl.surface = egl.GetCurrentSurface(EGL_DRAW);
if( negl.surface == EGL_NO_SURFACE )
return;
// now check if swapBuffers does not give error
if( egl.SwapBuffers( negl.dpy, negl.surface ) == EGL_FALSE )
return;
// double check
if( egl.GetError() != EGL_SUCCESS )
return;
__android_log_print( ANDROID_LOG_VERBOSE, "Xash", "native EGL enabled" );
negl.valid = true;
}
/*
========================
Android_GetGLAttribute
========================
*/
static int Android_GetGLAttribute( int eglAttr )
{
int ret = (*jni.env)->CallStaticIntMethod( jni.env, jni.actcls, jni.getGLAttribute, eglAttr );
// Con_Reportf( "Android_GetGLAttribute( %i ) => %i\n", eglAttr, ret );
return ret;
}
int Android_GetSelectedPixelFormat( void )
{
return (*jni.env)->CallStaticIntMethod( jni.env, jni.actcls, jni.getSelectedPixelFormat );
}
qboolean R_Init_Video( const int type )
{
char buf[MAX_VA_STRING];
qboolean retval;
switch( Android_GetSelectedPixelFormat() )
{
case 1:
refState.desktopBitsPixel = 16;
break;
case 2:
refState.desktopBitsPixel = 8;
break;
default:
refState.desktopBitsPixel = 32;
break;
}
if( FS_FileExists( GI->iconpath, true ) )
{
Q_snprintf( buf, sizeof( buf ), "%s/%s/%s", COM_CheckStringEmpty( host.rodir ) ? host.rodir : host.rootdir, GI->gamefolder, GI->iconpath );
Android_SetIcon( buf );
}
Android_SetTitle( GI->title );
VID_StartupGamma();
switch( type )
{
case REF_SOFTWARE:
glw_state.software = true;
break;
case REF_GL:
glw_state.software = false;
Sys_LoadLibrary( &egl_info );
if( !glw_state.safe && Sys_GetParmFromCmdLine( "-safegl", buf ) )
glw_state.safe = bound( SAFE_NO, Q_atoi( buf ), SAFE_DONTCARE );
break;
default:
Host_Error( "Can't initialize unknown context type %d!\n", type );
break;
}
if( glw_state.software )
{
uint arg;
// Con_Reportf( S_ERROR "Native software mode isn't supported on Android yet! :(\n" );
// return false;
Sys_LoadLibrary( &android_info );
Android_UpdateSurface( true );
if( !SW_CreateBuffer( jni.width, jni.height, &arg, &arg, &arg, &arg, &arg ) )
return false;
}
while( !(retval = VID_SetMode()) )
{
glw_state.safe++;
if( glw_state.safe > SAFE_LAST )
return false;
}
switch( type )
{
case REF_GL:
// refdll also can check extensions
ref.dllFuncs.GL_InitExtensions();
break;
case REF_SOFTWARE:
default:
break;
}
host.renderinfo_changed = false;
return true;
}
void R_Free_Video( void )
{
// (*jni.env)->CallStaticBooleanMethod( jni.env, jni.actcls, jni.deleteGLContext );
// VID_DestroyWindow ();
// R_FreeVideoModes();
Sys_FreeLibrary( &android_info );
Sys_FreeLibrary( &egl_info );
vid_android.has_context = false;
ref.dllFuncs.GL_ClearExtensions();
}
#define COPY_ATTR_IF_SET( refattr, attr ) \
if( vid_android.gl_attribs_set[refattr] ) \
{ \
attribs[i++] = attr; \
attribs[i++] = vid_android.gl_attribs[refattr]; \
}
static size_t VID_GenerateConfig( EGLint *attribs, size_t size )
{
size_t i = 0;
memset( attribs, 0, size * sizeof( EGLint ) );
vid_android.gles1 = false;
memset( vid_android.gl_attribs, 0, sizeof( vid_android.gl_attribs ));
memset( vid_android.gl_attribs_set, 0, sizeof( vid_android.gl_attribs_set ));
// refdll can request some attributes
ref.dllFuncs.GL_SetupAttributes( glw_state.safe );
COPY_ATTR_IF_SET( REF_GL_RED_SIZE, EGL_RED_SIZE );
COPY_ATTR_IF_SET( REF_GL_GREEN_SIZE, EGL_GREEN_SIZE );
COPY_ATTR_IF_SET( REF_GL_BLUE_SIZE, EGL_BLUE_SIZE );
COPY_ATTR_IF_SET( REF_GL_ALPHA_SIZE, EGL_ALPHA_SIZE );
COPY_ATTR_IF_SET( REF_GL_DEPTH_SIZE, EGL_DEPTH_SIZE );
COPY_ATTR_IF_SET( REF_GL_STENCIL_SIZE, EGL_STENCIL_SIZE );
COPY_ATTR_IF_SET( REF_GL_MULTISAMPLEBUFFERS, EGL_SAMPLE_BUFFERS );
COPY_ATTR_IF_SET( REF_GL_MULTISAMPLESAMPLES, EGL_SAMPLES );
if( vid_android.gl_attribs_set[REF_GL_ACCELERATED_VISUAL] )
{
attribs[i++] = EGL_CONFIG_CAVEAT;
attribs[i++] = vid_android.gl_attribs[REF_GL_ACCELERATED_VISUAL] ? EGL_NONE : EGL_DONT_CARE;
}
// BigGL support
attribs[i++] = EGL_RENDERABLE_TYPE;
vid_android.gl_api = EGL_OPENGL_ES_API;
if( vid_android.gl_attribs_set[REF_GL_CONTEXT_PROFILE_MASK] &&
!( vid_android.gl_attribs[REF_GL_CONTEXT_PROFILE_MASK] & REF_GL_CONTEXT_PROFILE_ES ))
{
attribs[i++] = EGL_OPENGL_BIT;
vid_android.gl_api = EGL_OPENGL_API;
}
else if( vid_android.gl_attribs_set[REF_GL_CONTEXT_MAJOR_VERSION] &&
vid_android.gl_attribs[REF_GL_CONTEXT_MAJOR_VERSION] >= 2 )
{
attribs[i++] = EGL_OPENGL_ES2_BIT;
}
else
{
i--; // erase EGL_RENDERABLE_TYPE
vid_android.gles1 = true;
}
attribs[i++] = EGL_NONE;
return i;
}
static size_t VID_GenerateContextConfig( EGLint *attribs, size_t size )
{
size_t i = 0;
memset( attribs, 0, size * sizeof( EGLint ));
/*if( Q_strcmp( negl.extensions, " EGL_KHR_create_context ") )
{
if( vid_android.gl_attribs_set[REF_GL_CONTEXT_FLAGS] )
{
attribs[i++] = 0x30FC; // EGL_CONTEXT_FLAGS_KHR
attribs[i++] = vid_android.gl_attribs[REF_GL_CONTEXT_FLAGS] & ((REF_GL_CONTEXT_ROBUST_ACCESS_FLAG << 1) - 1);
}
if( vid_android.gl_attribs_set[REF_GL_CONTEXT_PROFILE_MASK] )
{
int val = vid_android.gl_attribs[REF_GL_CONTEXT_PROFILE_MASK];
if( val & ( (REF_GL_CONTEXT_PROFILE_COMPATIBILITY << 1) - 1 ) )
{
attribs[i++] = 0x30FD; // EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR;
attribs[i++] = val;
}
}
COPY_ATTR_IF_SET( REF_GL_CONTEXT_MAJOR_VERSION, EGL_CONTEXT_CLIENT_VERSION );
COPY_ATTR_IF_SET( REF_GL_CONTEXT_MINOR_VERSION, 0x30FB );
}
else*/
{
// without extension we can set only major version
COPY_ATTR_IF_SET( REF_GL_CONTEXT_MAJOR_VERSION, EGL_CONTEXT_CLIENT_VERSION );
}
attribs[i++] = EGL_NONE;
return i;
}
qboolean VID_SetMode( void )
{
EGLint format;
jintArray attribs, contextAttribs;
static EGLint nAttribs[32+1], nContextAttribs[32+1];
const size_t attribsSize = ARRAYSIZE( nAttribs );
size_t s1, s2;
if( vid_android.has_context )
{
R_ChangeDisplaySettings( 0, 0, false ); // width and height are ignored anyway
return true;
}
s1 = VID_GenerateConfig(nAttribs, attribsSize);
s2 = VID_GenerateContextConfig(nContextAttribs, attribsSize);
attribs = (*jni.env)->NewIntArray( jni.env, s1 );
contextAttribs = (*jni.env)->NewIntArray( jni.env, s2 );
(*jni.env)->SetIntArrayRegion( jni.env, attribs, 0, s1, nAttribs );
(*jni.env)->SetIntArrayRegion( jni.env, contextAttribs, 0, s2, nContextAttribs );
R_ChangeDisplaySettings( 0, 0, false ); // width and height are ignored anyway
if( glw_state.software )
return true;
if( (*jni.env)->CallStaticBooleanMethod( jni.env, jni.actcls, jni.createGLContext, attribs, contextAttribs ) )
{
vid_android.has_context = true;
return true;
}
return false;
}
rserr_t R_ChangeDisplaySettings( int width, int height, qboolean fullscreen )
{
int render_w, render_h;
uint rotate = vid_rotate->value;
Android_GetScreenRes(&width, &height);
render_w = width;
render_h = height;
Con_Reportf( "R_ChangeDisplaySettings: forced resolution to %dx%d)\n", width, height);
if( ref.dllFuncs.R_SetDisplayTransform( rotate, 0, 0, vid_scale->value, vid_scale->value ) )
{
if( rotate & 1 )
{
int swap = render_w;
render_w = render_h;
render_h = swap;
}
render_h /= vid_scale->value;
render_w /= vid_scale->value;
}
else
{
Con_Printf( S_WARN "failed to setup screen transform\n" );
}
R_SaveVideoMode( width, height, render_w, render_h );
refState.wideScreen = true; // V_AdjustFov will check for widescreen
return rserr_ok;
}
int GL_SetAttribute( int attr, int val )
{
if( attr < 0 || attr >= REF_GL_ATTRIBUTES_COUNT )
return -1;
vid_android.gl_attribs[attr] = val;
vid_android.gl_attribs_set[attr] = true;
return 0;
}
int GL_GetAttribute( int attr, int *val )
{
EGLBoolean ret;
if( attr < 0 || attr >= REF_GL_ATTRIBUTES_COUNT )
return -1;
if( !val )
return -1;
switch( attr )
{
case REF_GL_RED_SIZE:
*val = Android_GetGLAttribute( EGL_RED_SIZE );
return 0;
case REF_GL_GREEN_SIZE:
*val = Android_GetGLAttribute( EGL_GREEN_SIZE );
return 0;
case REF_GL_BLUE_SIZE:
*val = Android_GetGLAttribute( EGL_BLUE_SIZE );
return 0;
case REF_GL_ALPHA_SIZE:
*val = Android_GetGLAttribute( EGL_ALPHA_SIZE );
return 0;
case REF_GL_DEPTH_SIZE:
*val = Android_GetGLAttribute( EGL_DEPTH_SIZE );
return 0;
case REF_GL_STENCIL_SIZE:
*val = Android_GetGLAttribute( EGL_STENCIL_SIZE );
return 0;
case REF_GL_MULTISAMPLESAMPLES:
*val = Android_GetGLAttribute( EGL_SAMPLES );
return 0;
}
return -1;
}
int R_MaxVideoModes( void )
{
return 0;
}
vidmode_t* R_GetVideoMode( int num )
{
return NULL;
}
void* GL_GetProcAddress( const char *name ) // RenderAPI requirement
{
void *gles;
void *addr;
if( vid_android.gles1 )
{
if( !vid_android.libgles1 )
vid_android.libgles1 = dlopen("libGLESv1_CM.so", RTLD_NOW);
gles = vid_android.libgles1;
}
else
{
if( !vid_android.libgles2 )
vid_android.libgles2 = dlopen("libGLESv2.so", RTLD_NOW);
gles = vid_android.libgles2;
}
if( gles && ( addr = dlsym(gles, name ) ) )
return addr;
if( !egl.GetProcAddress )
return NULL;
return egl.GetProcAddress( name );
}
void GL_UpdateSwapInterval( void )
{
// disable VSync while level is loading
if( cls.state < ca_active )
{
Android_SwapInterval( 0 );
SetBits( gl_vsync->flags, FCVAR_CHANGED );
}
else if( FBitSet( gl_vsync->flags, FCVAR_CHANGED ))
{
ClearBits( gl_vsync->flags, FCVAR_CHANGED );
Android_SwapInterval( gl_vsync->value );
}
}
void *SW_LockBuffer( void )
{
ANativeWindow_Buffer buffer;
if( !nw.lock || !vid_android.window )
return NULL;
if( nw.lock( vid_android.window, &buffer, NULL ) )
return NULL;
if( buffer.width < refState.width || buffer.height < refState.height )
return NULL;
return buffer.bits;
}
void SW_UnlockBuffer( void )
{
if( nw.unlockAndPost )
nw.unlockAndPost( vid_android.window );
}
qboolean SW_CreateBuffer( int width, int height, uint *stride, uint *bpp, uint *r, uint *g, uint *b )
{
ANativeWindow_Buffer buffer;
int lock;
if( !nw.lock || !vid_android.window )
return false;
nw.unlockAndPost( vid_android.window );
if( ( lock = nw.lock( vid_android.window, &buffer, NULL ) ) )
{
Con_Printf( "SW_CreateBuffer: lock %d\n", lock );
return false;
}
nw.unlockAndPost( vid_android.window );
Con_Printf( "SW_CreateBuffer: buffer %d %d %x %d %p\n", buffer.width, buffer.height, buffer.format, buffer.stride, buffer.bits );
if( width > buffer.width || height > buffer.height )
{
Con_Printf( "SW_CreateBuffer: buffer too small %d %d\n", width, height );
// resize event missed?
if( jni.width < buffer.width )
jni.width = buffer.width;
if( jni.height < buffer.height )
jni.width = buffer.height;
VID_SetMode();
Android_UpdateSurface( 1 );
return false;
}
if( buffer.format != WINDOW_FORMAT_RGB_565 )
{
Con_Printf( "SW_CreateBuffer: wrong format %d\n", buffer.format );
return false;
}
Con_Printf( "SW_CreateBuffer: ok\n" );
*stride = buffer.stride;
*bpp = 2;
*r = (((1 << 5) - 1) << (5+6));
*g = (((1 << 6) - 1) << (5));
*b = (((1 << 5) - 1) << (0));
return true;
}

9
engine/platform/platform.h
Unescape View File

@ -47,9 +47,9 @@ void Android_SaveID( const char *id );
#if XASH_WIN32 #if XASH_WIN32
void Platform_UpdateStatusLine( void ); void Platform_UpdateStatusLine( void );
#else #else
static inline void Platform_UpdateStatusLine( void ) { } static inline void Platform_UpdateStatusLine( void ) { }
#endif #endif
#if XASH_NSWITCH #if XASH_NSWITCH
void NSwitch_Init( void ); void NSwitch_Init( void );
@ -108,11 +108,6 @@ void Platform_SetClipboardText( const char *buffer );
#define SDL_VERSION_ATLEAST( x, y, z ) 0 #define SDL_VERSION_ATLEAST( x, y, z ) 0
#endif #endif
#if XASH_ANDROID
void Android_ShowMouse( qboolean show );
void Android_MouseMove( float *x, float *y );
#endif
/* /*
============================================================================== ==============================================================================

Write Preview
Loading…
Cancel
Save