From 7fbb15bc63c7937cab772bd942883e3811acbabf Mon Sep 17 00:00:00 2001 From: Sylvain Beucler Date: Sun, 11 Mar 2012 16:01:29 +0000 Subject: [PATCH] Rename Android and EGL files git-svn-id: svn+ssh://svn.code.sf.net/p/freeglut/code/trunk/freeglut/freeglut@1114 7f0cb862-5218-0410-a997-914c9d46530a --- src/android/fg_gamemode_android.c | 57 ++++ src/android/fg_input_devices_android.c | 68 +++++ src/android/fg_internal_android.h | 86 ++++++ src/android/fg_joystick_android.c | 50 ++++ src/android/fg_main_android.c | 403 ++++++++++++++++++++++++++ src/android/fg_runtime_android.c | 160 ++++++++++ src/android/fg_spaceball_android.c | 58 ++++ src/android/fg_state_android.c | 113 ++++++++ src/android/fg_window_android.c | 165 +++++++++++ src/android/freeglut_gamemode_android.c | 57 ---- src/android/freeglut_input_devices_android.c | 69 ----- src/android/freeglut_internal_android.h | 86 ------ src/android/freeglut_joystick_android.c | 50 ---- src/android/freeglut_main_android.c | 403 -------------------------- src/android/freeglut_runtime_android.c | 160 ---------- src/android/freeglut_spaceball_android.c | 58 ---- src/android/freeglut_state_android.c | 113 -------- src/android/freeglut_window_android.c | 165 ----------- src/android/opengles_stubs.c | 2 +- src/egl/fg_display_egl.c | 36 +++ src/egl/fg_init_egl.c | 80 +++++ src/egl/fg_internal_egl.h | 68 +++++ src/egl/fg_structure_egl.c | 34 +++ src/egl/fg_window_egl.c | 129 +++++++++ src/egl/freeglut_display_egl.c | 36 --- src/egl/freeglut_init_egl.c | 80 ----- src/egl/freeglut_internal_egl.h | 68 ----- src/egl/freeglut_structure_egl.c | 34 --- src/egl/freeglut_window_egl.c | 129 --------- 29 files changed, 1508 insertions(+), 1509 deletions(-) create mode 100644 src/android/fg_gamemode_android.c create mode 100644 src/android/fg_input_devices_android.c create mode 100644 src/android/fg_internal_android.h create mode 100644 src/android/fg_joystick_android.c create mode 100644 src/android/fg_main_android.c create mode 100644 src/android/fg_runtime_android.c create mode 100644 src/android/fg_spaceball_android.c create mode 100644 src/android/fg_state_android.c create mode 100644 src/android/fg_window_android.c delete mode 100644 src/android/freeglut_gamemode_android.c delete mode 100644 src/android/freeglut_input_devices_android.c delete mode 100644 src/android/freeglut_internal_android.h delete mode 100644 src/android/freeglut_joystick_android.c delete mode 100644 src/android/freeglut_main_android.c delete mode 100644 src/android/freeglut_runtime_android.c delete mode 100644 src/android/freeglut_spaceball_android.c delete mode 100644 src/android/freeglut_state_android.c delete mode 100644 src/android/freeglut_window_android.c create mode 100644 src/egl/fg_display_egl.c create mode 100644 src/egl/fg_init_egl.c create mode 100644 src/egl/fg_internal_egl.h create mode 100644 src/egl/fg_structure_egl.c create mode 100644 src/egl/fg_window_egl.c delete mode 100644 src/egl/freeglut_display_egl.c delete mode 100644 src/egl/freeglut_init_egl.c delete mode 100644 src/egl/freeglut_internal_egl.h delete mode 100644 src/egl/freeglut_structure_egl.c delete mode 100644 src/egl/freeglut_window_egl.c diff --git a/src/android/fg_gamemode_android.c b/src/android/fg_gamemode_android.c new file mode 100644 index 0000000..8cd3034 --- /dev/null +++ b/src/android/fg_gamemode_android.c @@ -0,0 +1,57 @@ +/* + * freeglut_gamemode_x11.c + * + * The game mode handling code. + * + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include "fg_internal.h" + +/* + * Changes the current display mode to match user's settings + */ +GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest ) +{ + fprintf(stderr, "fgPlatformChangeDisplayMode: STUB\n"); + return GL_FALSE; +} + +void fgPlatformEnterGameMode( void ) +{ + fprintf(stderr, "fgPlatformEnterGameMode: STUB\n"); +} + +void fgPlatformRememberState( void ) +{ + fprintf(stderr, "fgPlatformRememberState: STUB\n"); +} + +void fgPlatformRestoreState( void ) +{ + fprintf(stderr, "fgPlatformRestoreState: STUB\n"); +} + +void fgPlatformLeaveGameMode( void ) +{ + fprintf(stderr, "fgPlatformLeaveGameMode: STUB\n"); +} + diff --git a/src/android/fg_input_devices_android.c b/src/android/fg_input_devices_android.c new file mode 100644 index 0000000..ac3aea5 --- /dev/null +++ b/src/android/fg_input_devices_android.c @@ -0,0 +1,68 @@ +/* + * freeglut_input_devices_android.c + * + * Handles miscellaneous input devices via direct serial-port access. + * + * Written by Joe Krahn 2005 + * Copyright (c) 2005 Stephen J. Baker. All Rights Reserved. + * Copied for Platform code by Evan Felix + * Copyright 2012 (C) Sylvain Beucler + * Creation date: Thur Feb 2 2012 + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA OR STEPHEN J. BAKER 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 SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +typedef struct _serialport SERIALPORT; + +/* + * Try initializing the input device(s) + */ +void fgPlatformRegisterDialDevice ( const char *dial_device ) +{ + fprintf(stderr, "fgPlatformRegisterDialDevice: STUB\n"); +} + +SERIALPORT *serial_open ( const char *device ) +{ + fprintf(stderr, "serial_open: STUB\n"); + return NULL; +} + +void serial_close(SERIALPORT *port) +{ + fprintf(stderr, "serial_close: STUB\n"); +} + +int serial_getchar(SERIALPORT *port) +{ + fprintf(stderr, "serial_getchar: STUB\n"); + return EOF; +} + +int serial_putchar(SERIALPORT *port, unsigned char ch) +{ + fprintf(stderr, "serial_putchar: STUB\n"); + return 0; +} + +void serial_flush ( SERIALPORT *port ) +{ + fprintf(stderr, "serial_flush: STUB\n"); +} diff --git a/src/android/fg_internal_android.h b/src/android/fg_internal_android.h new file mode 100644 index 0000000..83373de --- /dev/null +++ b/src/android/fg_internal_android.h @@ -0,0 +1,86 @@ +/* + * freeglut_internal_android.h + * + * The freeglut library private include file. + * + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef FREEGLUT_INTERNAL_ANDROID_H +#define FREEGLUT_INTERNAL_ANDROID_H + + +/* -- PLATFORM-SPECIFIC INCLUDES ------------------------------------------- */ +/* Android OpenGL ES is accessed through EGL */ +#include "egl/fg_internal_egl.h" + +/** + * Virtual PAD (spots on touchscreen that simulate keys) + */ +struct vpad_state { + bool on; + bool left; + bool right; + bool up; + bool down; +}; +struct touchscreen { + struct vpad_state vpad; + bool in_mmotion; +}; + + +/* -- JOYSTICK-SPECIFIC STRUCTURES AND TYPES ------------------------------- */ +/* + * Initial defines from "js.h" starting around line 33 with the existing "freeglut_joystick.c" + * interspersed + */ + + /* + * We'll put these values in and that should + * allow the code to at least compile when there is + * no support. The JS open routine should error out + * and shut off all the code downstream anyway and if + * the application doesn't use a joystick we'll be fine. + */ + + struct JS_DATA_TYPE + { + int buttons; + int x; + int y; + }; + +# define JS_RETURN (sizeof(struct JS_DATA_TYPE)) + +/* XXX It might be better to poll the operating system for the numbers of buttons and + * XXX axes and then dynamically allocate the arrays. + */ +# define _JS_MAX_AXES 16 +typedef struct tagSFG_PlatformJoystick SFG_PlatformJoystick; +struct tagSFG_PlatformJoystick +{ + struct JS_DATA_TYPE js; + + char fname [ 128 ]; + int fd; +}; + +#endif /* FREEGLUT_INTERNAL_ANDROID_H */ diff --git a/src/android/fg_joystick_android.c b/src/android/fg_joystick_android.c new file mode 100644 index 0000000..5328285 --- /dev/null +++ b/src/android/fg_joystick_android.c @@ -0,0 +1,50 @@ +/* + * freeglut_joystick_android.c + * + * Joystick handling code + * + * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved. + * Written by Steve Baker, + * Copied for Platform code by Evan Felix + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include "fg_internal.h" + +void fgPlatformJoystickRawRead( SFG_Joystick* joy, int* buttons, float* axes ) +{ + fprintf(stderr, "fgPlatformJoystickRawRead: STUB\n"); +} + +void fgPlatformJoystickOpen( SFG_Joystick* joy ) +{ + fprintf(stderr, "fgPlatformJoystickOpen: STUB\n"); +} + +void fgPlatformJoystickInit( SFG_Joystick *fgJoystick[], int ident ) +{ + fprintf(stderr, "fgJoystick: STUB\n"); +} + +void fgPlatformJoystickClose ( int ident ) +{ + fprintf(stderr, "fgPlatformJoystickClose: STUB\n"); +} diff --git a/src/android/fg_main_android.c b/src/android/fg_main_android.c new file mode 100644 index 0000000..83aac13 --- /dev/null +++ b/src/android/fg_main_android.c @@ -0,0 +1,403 @@ +/* + * freeglut_main_android.c + * + * The Android-specific windows message processing methods. + * + * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved. + * Written by Pawel W. Olszta, + * Copied for Platform code by Evan Felix + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include "fg_internal.h" + +#include +#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FreeGLUT", __VA_ARGS__)) +#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "FreeGLUT", __VA_ARGS__)) +#include +#include + +static struct touchscreen touchscreen; +static unsigned char key_a2fg[256]; + +/* Cf. http://developer.android.com/reference/android/view/KeyEvent.html */ +/* These codes are missing in */ +/* Don't convert to enum, since it may conflict with future version of + that */ +#define AKEYCODE_FORWARD_DEL 112 +#define AKEYCODE_CTRL_LEFT 113 +#define AKEYCODE_CTRL_RIGHT 114 +#define AKEYCODE_MOVE_HOME 122 +#define AKEYCODE_MOVE_END 123 +#define AKEYCODE_INSERT 124 +#define AKEYCODE_ESCAPE 127 +#define AKEYCODE_F1 131 +#define AKEYCODE_F2 132 +#define AKEYCODE_F3 133 +#define AKEYCODE_F4 134 +#define AKEYCODE_F5 135 +#define AKEYCODE_F6 136 +#define AKEYCODE_F7 137 +#define AKEYCODE_F8 138 +#define AKEYCODE_F9 139 +#define AKEYCODE_F10 140 +#define AKEYCODE_F11 141 +#define AKEYCODE_F12 142 + +#define EVENT_HANDLED 1 +#define EVENT_NOT_HANDLED 0 + +/** + * Initialize Android keycode to GLUT keycode mapping + */ +static void key_init() { + memset(key_a2fg, 0, sizeof(key_a2fg)); + + key_a2fg[AKEYCODE_F1] = GLUT_KEY_F1; + key_a2fg[AKEYCODE_F2] = GLUT_KEY_F2; + key_a2fg[AKEYCODE_F3] = GLUT_KEY_F3; + key_a2fg[AKEYCODE_F4] = GLUT_KEY_F4; + key_a2fg[AKEYCODE_F5] = GLUT_KEY_F5; + key_a2fg[AKEYCODE_F6] = GLUT_KEY_F6; + key_a2fg[AKEYCODE_F7] = GLUT_KEY_F7; + key_a2fg[AKEYCODE_F8] = GLUT_KEY_F8; + key_a2fg[AKEYCODE_F9] = GLUT_KEY_F9; + key_a2fg[AKEYCODE_F10] = GLUT_KEY_F10; + key_a2fg[AKEYCODE_F11] = GLUT_KEY_F11; + key_a2fg[AKEYCODE_F12] = GLUT_KEY_F12; + + key_a2fg[AKEYCODE_PAGE_UP] = GLUT_KEY_PAGE_UP; + key_a2fg[AKEYCODE_PAGE_DOWN] = GLUT_KEY_PAGE_DOWN; + key_a2fg[AKEYCODE_MOVE_HOME] = GLUT_KEY_HOME; + key_a2fg[AKEYCODE_MOVE_END] = GLUT_KEY_END; + key_a2fg[AKEYCODE_INSERT] = GLUT_KEY_INSERT; + + key_a2fg[AKEYCODE_DPAD_UP] = GLUT_KEY_UP; + key_a2fg[AKEYCODE_DPAD_DOWN] = GLUT_KEY_DOWN; + key_a2fg[AKEYCODE_DPAD_LEFT] = GLUT_KEY_LEFT; + key_a2fg[AKEYCODE_DPAD_RIGHT] = GLUT_KEY_RIGHT; + + key_a2fg[AKEYCODE_ALT_LEFT] = GLUT_KEY_ALT_L; + key_a2fg[AKEYCODE_ALT_RIGHT] = GLUT_KEY_ALT_R; + key_a2fg[AKEYCODE_SHIFT_LEFT] = GLUT_KEY_SHIFT_L; + key_a2fg[AKEYCODE_SHIFT_RIGHT] = GLUT_KEY_SHIFT_R; + key_a2fg[AKEYCODE_CTRL_LEFT] = GLUT_KEY_CTRL_L; + key_a2fg[AKEYCODE_CTRL_RIGHT] = GLUT_KEY_CTRL_R; +} + +/** + * Convert an Android key event to ASCII. + */ +static unsigned char key_ascii(struct android_app* app, AInputEvent* event) { + int32_t code = AKeyEvent_getKeyCode(event); + + /* Handle a few special cases: */ + switch (code) { + case AKEYCODE_DEL: + return 8; + case AKEYCODE_FORWARD_DEL: + return 127; + case AKEYCODE_ESCAPE: + return 27; + } + + /* Get usable JNI context */ + JNIEnv* env = app->activity->env; + JavaVM* vm = app->activity->vm; + (*vm)->AttachCurrentThread(vm, &env, NULL); + + jclass KeyEventClass = (*env)->FindClass(env, "android/view/KeyEvent"); + jmethodID KeyEventConstructor = (*env)->GetMethodID(env, KeyEventClass, "", "(II)V"); + jobject keyEvent = (*env)->NewObject(env, KeyEventClass, KeyEventConstructor, + AKeyEvent_getAction(event), AKeyEvent_getKeyCode(event)); + jmethodID KeyEvent_getUnicodeChar = (*env)->GetMethodID(env, KeyEventClass, "getUnicodeChar", "(I)I"); + int ascii = (*env)->CallIntMethod(env, keyEvent, KeyEvent_getUnicodeChar, AKeyEvent_getMetaState(event)); + + /* LOGI("getUnicodeChar(%d) = %d ('%c')", AKeyEvent_getKeyCode(event), ascii, ascii); */ + + return ascii; +} + +/* + * Handle a window configuration change. When no reshape + * callback is hooked, the viewport size is updated to + * match the new window size. + */ +void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height ) +{ + fprintf(stderr, "fgPlatformReshapeWindow: STUB\n"); +} + +/* + * A static helper function to execute display callback for a window + */ +void fgPlatformDisplayWindow ( SFG_Window *window ) +{ + fghRedrawWindow ( window ) ; +} + +unsigned long fgPlatformSystemTime ( void ) +{ + struct timeval now; + gettimeofday( &now, NULL ); + return now.tv_usec/1000 + now.tv_sec*1000; +} + +/* + * Does the magic required to relinquish the CPU until something interesting + * happens. + */ +void fgPlatformSleepForEvents( long msec ) +{ + /* fprintf(stderr, "fgPlatformSleepForEvents: STUB\n"); */ +} + +/** + * Process the next input event. + */ +int32_t handle_input(struct android_app* app, AInputEvent* event) { + SFG_Window* window = fgStructure.CurrentWindow; + + /* FIXME: in Android, when key is repeated, down and up events + happen most often at the exact same time. This makes it + impossible to animate based on key press time. */ + /* e.g. down/up/wait/down/up rather than down/wait/down/wait/up */ + + if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_KEY) { + /* LOGI("action: %d", AKeyEvent_getAction(event)); */ + /* LOGI("keycode: %d", code); */ + int32_t code = AKeyEvent_getKeyCode(event); + + if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_DOWN) { + int32_t keypress = 0; + unsigned char ascii = 0; + if ((keypress = key_a2fg[code]) && FETCH_WCB(*window, Special)) { + INVOKE_WCB(*window, Special, (keypress, window->State.MouseX, window->State.MouseY)); + return EVENT_HANDLED; + } else if ((ascii = key_ascii(app, event)) && FETCH_WCB(*window, Keyboard)) { + INVOKE_WCB(*window, Keyboard, (ascii, window->State.MouseX, window->State.MouseY)); + return EVENT_HANDLED; + } + } + else if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_UP) { + int32_t keypress = 0; + unsigned char ascii = 0; + if ((keypress = key_a2fg[code]) && FETCH_WCB(*window, Special)) { + INVOKE_WCB(*window, SpecialUp, (keypress, window->State.MouseX, window->State.MouseY)); + return EVENT_HANDLED; + } else if ((ascii = key_ascii(app, event)) && FETCH_WCB(*window, Keyboard)) { + INVOKE_WCB(*window, KeyboardUp, (ascii, window->State.MouseX, window->State.MouseY)); + return EVENT_HANDLED; + } + } + } + + if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) { + int32_t action = AMotionEvent_getAction(event); + float x = AMotionEvent_getX(event, 0); + float y = AMotionEvent_getY(event, 0); + LOGI("motion %.01f,%.01f action=%d", x, y, AMotionEvent_getAction(event)); + + /* Virtual arrows PAD */ + // Don't interfere with existing mouse move event + if (!touchscreen.in_mmotion) { + struct vpad_state prev_vpad = touchscreen.vpad; + touchscreen.vpad.left = touchscreen.vpad.right + = touchscreen.vpad.up = touchscreen.vpad.down = false; + + int32_t width = ANativeWindow_getWidth(window->Window.Handle); + int32_t height = ANativeWindow_getHeight(window->Window.Handle); + if (action == AMOTION_EVENT_ACTION_DOWN || action == AMOTION_EVENT_ACTION_MOVE) { + if ((x > 0 && x < 100) && (y > (height - 100) && y < height)) + touchscreen.vpad.left = true; + if ((x > 200 && x < 300) && (y > (height - 100) && y < height)) + touchscreen.vpad.right = true; + if ((x > 100 && x < 200) && (y > (height - 100) && y < height)) + touchscreen.vpad.down = true; + if ((x > 100 && x < 200) && (y > (height - 200) && y < (height - 100))) + touchscreen.vpad.up = true; + } + if (action == AMOTION_EVENT_ACTION_DOWN && + (touchscreen.vpad.left || touchscreen.vpad.right || touchscreen.vpad.down || touchscreen.vpad.up)) + touchscreen.vpad.on = true; + if (action == AMOTION_EVENT_ACTION_UP) + touchscreen.vpad.on = false; + if (prev_vpad.left != touchscreen.vpad.left + || prev_vpad.right != touchscreen.vpad.right + || prev_vpad.up != touchscreen.vpad.up + || prev_vpad.down != touchscreen.vpad.down + || prev_vpad.on != touchscreen.vpad.on) { + if (FETCH_WCB(*window, Special)) { + if (prev_vpad.left == false && touchscreen.vpad.left == true) + INVOKE_WCB(*window, Special, (GLUT_KEY_LEFT, x, y)); + else if (prev_vpad.right == false && touchscreen.vpad.right == true) + INVOKE_WCB(*window, Special, (GLUT_KEY_RIGHT, x, y)); + else if (prev_vpad.up == false && touchscreen.vpad.up == true) + INVOKE_WCB(*window, Special, (GLUT_KEY_UP, x, y)); + else if (prev_vpad.down == false && touchscreen.vpad.down == true) + INVOKE_WCB(*window, Special, (GLUT_KEY_DOWN, x, y)); + } + if (FETCH_WCB(*window, SpecialUp)) { + if (prev_vpad.left == true && touchscreen.vpad.left == false) + INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_LEFT, x, y)); + if (prev_vpad.right == true && touchscreen.vpad.right == false) + INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_RIGHT, x, y)); + if (prev_vpad.up == true && touchscreen.vpad.up == false) + INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_UP, x, y)); + if (prev_vpad.down == true && touchscreen.vpad.down == false) + INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_DOWN, x, y)); + } + return EVENT_HANDLED; + } + } + + /* Normal mouse events */ + if (!touchscreen.vpad.on) { + window->State.MouseX = x; + window->State.MouseY = y; + LOGI("Changed mouse position: %d,%d", x, y); + if (action == AMOTION_EVENT_ACTION_DOWN && FETCH_WCB(*window, Mouse)) { + touchscreen.in_mmotion = true; + INVOKE_WCB(*window, Mouse, (GLUT_LEFT_BUTTON, GLUT_DOWN, x, y)); + } else if (action == AMOTION_EVENT_ACTION_UP && FETCH_WCB(*window, Mouse)) { + touchscreen.in_mmotion = false; + INVOKE_WCB(*window, Mouse, (GLUT_LEFT_BUTTON, GLUT_UP, x, y)); + } else if (action == AMOTION_EVENT_ACTION_MOVE && FETCH_WCB(*window, Motion)) { + INVOKE_WCB(*window, Motion, (x, y)); + } + } + + return EVENT_HANDLED; + } + + /* Let Android handle other events (e.g. Back and Menu buttons) */ + return EVENT_NOT_HANDLED; +} + +/** + * Process the next main command. + */ +void handle_cmd(struct android_app* app, int32_t cmd) { + switch (cmd) { + case APP_CMD_SAVE_STATE: + /* The system has asked us to save our current state. Do so. */ + LOGI("handle_cmd: APP_CMD_SAVE_STATE"); + break; + case APP_CMD_INIT_WINDOW: + /* The window is being shown, get it ready. */ + LOGI("handle_cmd: APP_CMD_INIT_WINDOW"); + fgDisplay.pDisplay.single_window->Window.Handle = app->window; + /* glPlatformOpenWindow was waiting for Handle to be defined and + will now return from fgPlatformProcessSingleEvent() */ + break; + case APP_CMD_TERM_WINDOW: + /* The window is being hidden or closed, clean it up. */ + LOGI("handle_cmd: APP_CMD_TERM_WINDOW"); + fgDestroyWindow(fgDisplay.pDisplay.single_window); + break; + case APP_CMD_DESTROY: + /* Not reached because GLUT exit()s when last window is closed */ + LOGI("handle_cmd: APP_CMD_DESTROY"); + break; + case APP_CMD_GAINED_FOCUS: + LOGI("handle_cmd: APP_CMD_GAINED_FOCUS"); + break; + case APP_CMD_LOST_FOCUS: + LOGI("handle_cmd: APP_CMD_LOST_FOCUS"); + break; + case APP_CMD_CONFIG_CHANGED: + /* Handle rotation / orientation change */ + LOGI("handle_cmd: APP_CMD_CONFIG_CHANGED"); + break; + case APP_CMD_WINDOW_RESIZED: + LOGI("handle_cmd: APP_CMD_WINDOW_RESIZED"); + if (fgDisplay.pDisplay.single_window->Window.pContext.eglSurface != EGL_NO_SURFACE) + /* Make ProcessSingleEvent detect the new size, only available + after the next SwapBuffer */ + glutPostRedisplay(); + break; + default: + LOGI("handle_cmd: unhandled cmd=%d", cmd); + } +} + +void fgPlatformProcessSingleEvent ( void ) +{ + static int32_t last_width = -1; + static int32_t last_height = -1; + + /* When the screen is resized, the window handle still points to the + old window until the next SwapBuffer, while it's crucial to set + the size (onShape) correctly before the next onDisplay callback. + Plus we don't know if the next SwapBuffer already occurred at the + time we process the event (e.g. during onDisplay). */ + /* So we do the check each time rather than on event. */ + /* Interestingly, on a Samsung Galaxy S/PowerVR SGX540 GPU/Android + 2.3, that next SwapBuffer is fake (but still necessary to get the + new size). */ + SFG_Window* window = fgDisplay.pDisplay.single_window; + if (window != NULL && window->Window.Handle != NULL) { + int32_t width = ANativeWindow_getWidth(window->Window.Handle); + int32_t height = ANativeWindow_getHeight(window->Window.Handle); + if (width != last_width || height != last_height) { + last_width = width; + last_height = height; + LOGI("width=%d, height=%d", width, height); + if( FETCH_WCB( *window, Reshape ) ) + INVOKE_WCB( *window, Reshape, ( width, height ) ); + else + glViewport( 0, 0, width, height ); + glutPostRedisplay(); + } + } + + /* Read pending event. */ + int ident; + int events; + struct android_poll_source* source; + /* This is called "ProcessSingleEvent" but this means we'd only + process ~60 (screen Hz) mouse events per second, plus other ports + are processing all events already. So let's process all pending + events. */ + /* if ((ident=ALooper_pollOnce(0, NULL, &events, (void**)&source)) >= 0) { */ + while ((ident=ALooper_pollAll(0, NULL, &events, (void**)&source)) >= 0) { + /* Process this event. */ + if (source != NULL) { + source->process(source->app, source); + } + } +} + +void fgPlatformMainLoopPreliminaryWork ( void ) +{ + printf("fgPlatformMainLoopPreliminaryWork\n"); + + key_init(); + + /* Make sure glue isn't stripped. */ + /* JNI entry points need to be bundled even when linking statically */ + app_dummy(); +} + +void fgPlatformDeinitialiseInputDevices ( void ) +{ + fprintf(stderr, "fgPlatformDeinitialiseInputDevices: STUB\n"); +} diff --git a/src/android/fg_runtime_android.c b/src/android/fg_runtime_android.c new file mode 100644 index 0000000..e83c2d3 --- /dev/null +++ b/src/android/fg_runtime_android.c @@ -0,0 +1,160 @@ +/* + * freeglut_runtime_android.c + * + * Android runtime + * + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* Parts taken from Android NDK's 'native-activity' sample : */ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include "android/native_app_glue/android_native_app_glue.h" + +#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FreeGLUT", __VA_ARGS__)) +#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "FreeGLUT", __VA_ARGS__)) + +/* Cf. freeglut_main_android.c */ +extern int32_t handle_input(struct android_app* app, AInputEvent* event); +extern void handle_cmd(struct android_app* app, int32_t cmd); + +extern int main(int argc, char* argv[]); + +/** NativeActivity Callbacks **/ +/* Caution: they are called in the native_activity thread, not the + FreeGLUT thread. Use android_app_write_cmd. */ + +/* Could be used instead of onNativeWindowRedrawNeeded */ +/* Deals with status bar presence */ +static void onContentRectChanged(ANativeActivity* activity, const ARect* rect) { + LOGI("onContentRectChanged: l=%d,t=%d,r=%d,b=%d", rect->left, rect->top, rect->right, rect->bottom); +} + +/* Bug: not called during a resize in android-9, only once on startup :/ */ +static void onNativeWindowResized(ANativeActivity* activity, ANativeWindow* window) { + LOGI("onNativeWindowResized: %p\n", (void*)activity); +} + +/* Called after a resize, compensate broken onNativeWindowResized */ +static void onNativeWindowRedrawNeeded(ANativeActivity* activity, ANativeWindow* window) { + LOGI("onNativeWindowRedrawNeeded: %p\n", (void*)activity); + struct android_app* app = (struct android_app*)activity->instance; + //if (fgDisplay.pDisplay.single_window->Window.pContext.eglSurface != EGL_NO_SURFACE) + android_app_write_cmd(app, APP_CMD_WINDOW_RESIZED); +} + +/** + * Extract all .apk assets to the application directory so they can be + * accessed using accessed. + * TODO: parse directories recursively + */ +static void extract_assets(struct android_app* app) { + /* Get usable JNI context */ + JNIEnv* env = app->activity->env; + JavaVM* vm = app->activity->vm; + (*vm)->AttachCurrentThread(vm, &env, NULL); + + { + /* Get a handle on our calling NativeActivity class */ + jclass activityClass = (*env)->GetObjectClass(env, app->activity->clazz); + + /* Get path to cache dir (/data/data/org.myapp/cache) */ + jmethodID getCacheDir = (*env)->GetMethodID(env, activityClass, "getCacheDir", "()Ljava/io/File;"); + jobject file = (*env)->CallObjectMethod(env, app->activity->clazz, getCacheDir); + jclass fileClass = (*env)->FindClass(env, "java/io/File"); + jmethodID getAbsolutePath = (*env)->GetMethodID(env, fileClass, "getAbsolutePath", "()Ljava/lang/String;"); + jstring jpath = (jstring)(*env)->CallObjectMethod(env, file, getAbsolutePath); + const char* app_dir = (*env)->GetStringUTFChars(env, jpath, NULL); + + /* chdir in the application cache directory */ + LOGI("app_dir: %s", app_dir); + chdir(app_dir); + (*env)->ReleaseStringUTFChars(env, jpath, app_dir); + + /* Pre-extract assets, to avoid Android-specific file opening */ + { + AAssetManager* mgr = app->activity->assetManager; + AAssetDir* assetDir = AAssetManager_openDir(mgr, ""); + const char* filename = (const char*)NULL; + while ((filename = AAssetDir_getNextFileName(assetDir)) != NULL) { + AAsset* asset = AAssetManager_open(mgr, filename, AASSET_MODE_STREAMING); + char buf[BUFSIZ]; + int nb_read = 0; + FILE* out = fopen(filename, "w"); + while ((nb_read = AAsset_read(asset, buf, BUFSIZ)) > 0) + fwrite(buf, nb_read, 1, out); + fclose(out); + AAsset_close(asset); + } + AAssetDir_close(assetDir); + } + } +} + +/** + * This is the main entry point of a native application that is using + * android_native_app_glue. It runs in its own thread, with its own + * event loop for receiving input events and doing other things. + */ +void android_main(struct android_app* app) { + LOGI("android_main"); + + // Register window resize callback + app->activity->callbacks->onNativeWindowResized = onNativeWindowResized; + app->activity->callbacks->onContentRectChanged = onContentRectChanged; + app->activity->callbacks->onNativeWindowRedrawNeeded = onNativeWindowRedrawNeeded; + + app->onAppCmd = handle_cmd; + app->onInputEvent = handle_input; + + extract_assets(app); + + /* Call user's main */ + { + char progname[5] = "self"; + char* argv[] = {progname, NULL}; + main(1, argv); + } + + LOGI("android_main: end"); + exit(0); +} diff --git a/src/android/fg_spaceball_android.c b/src/android/fg_spaceball_android.c new file mode 100644 index 0000000..2f04d67 --- /dev/null +++ b/src/android/fg_spaceball_android.c @@ -0,0 +1,58 @@ +/* + * freeglut_spaceball_android.c + * + * Spaceball support for Windows + * + * Copyright (c) 2012 Stephen J. Baker. All Rights Reserved. + * Written by Evan Felix + * Creation date: Sat Feb 4, 2012 + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +/* + * This code is a very complicated way of doing nothing. + * But is needed for Android platform builds. + */ + +#include +#include "fg_internal.h" + +void fgPlatformInitializeSpaceball(void) +{ + return; +} + +void fgPlatformSpaceballClose(void) +{ + return; +} + +int fgPlatformHasSpaceball(void) +{ + return 0; +} + +int fgPlatformSpaceballNumButtons(void) +{ + return 0; +} + +void fgPlatformSpaceballSetWindow(SFG_Window *window) +{ + return; +} diff --git a/src/android/fg_state_android.c b/src/android/fg_state_android.c new file mode 100644 index 0000000..e22b86c --- /dev/null +++ b/src/android/fg_state_android.c @@ -0,0 +1,113 @@ +/* + * freeglut_state_android.c + * + * Android-specific freeglut state query methods. + * + * Copyright (c) 2012 Stephen J. Baker. All Rights Reserved. + * Written by John F. Fay, + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include +#include +#include "fg_internal.h" + +int fgPlatformGlutGet ( GLenum eWhat ) +{ + fprintf(stderr, "fgPlatformGlutGet: STUB\n"); + + switch (eWhat) { + case GLUT_WINDOW_WIDTH: + case GLUT_WINDOW_HEIGHT: + { + if ( fgStructure.CurrentWindow == NULL ) + return 0; + int32_t width = ANativeWindow_getWidth(fgStructure.CurrentWindow->Window.Handle); + int32_t height = ANativeWindow_getHeight(fgStructure.CurrentWindow->Window.Handle); + switch ( eWhat ) + { + case GLUT_WINDOW_WIDTH: + return width; + case GLUT_WINDOW_HEIGHT: + return height; + } + } + } + return -1; +} + +int fgPlatformGlutDeviceGet ( GLenum eWhat ) +{ + fprintf(stderr, "fgPlatformGlutDeviceGet: STUB\n"); + return -1; +} + +int fgPlatformGlutLayerGet( GLenum eWhat ) +{ + /* + * This is easy as layers are not implemented ;-) + * + * XXX Can we merge the UNIX/X11 and WIN32 sections? Or + * XXX is overlay support planned? + */ + switch( eWhat ) + { + case GLUT_OVERLAY_POSSIBLE: + return 0; + + case GLUT_LAYER_IN_USE: + return GLUT_NORMAL; + + case GLUT_HAS_OVERLAY: + return 0; + + case GLUT_TRANSPARENT_INDEX: + /* + * Return just anything, which is always defined as zero + * + * XXX HUH? + */ + return 0; + + case GLUT_NORMAL_DAMAGED: + /* XXX Actually I do not know. Maybe. */ + return 0; + + case GLUT_OVERLAY_DAMAGED: + return -1; + + default: + fgWarning( "glutLayerGet(): missing enum handle %d", eWhat ); + break; + } + + /* And fail. That's good. Programs do love failing. */ + return -1; +} + + +int *fgPlatformGlutGetModeValues(GLenum eWhat, int *size) +{ + fprintf(stderr, "fgPlatformGlutGetModeValues: STUB\n"); + return NULL; +} + + diff --git a/src/android/fg_window_android.c b/src/android/fg_window_android.c new file mode 100644 index 0000000..8b1f682 --- /dev/null +++ b/src/android/fg_window_android.c @@ -0,0 +1,165 @@ +/* + * freeglut_window_android.c + * + * Window management methods for Android + * + * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved. + * Written by Pawel W. Olszta, + * Copied for Platform code by Evan Felix + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#define FREEGLUT_BUILDING_LIB +#include +#include "fg_internal.h" +extern EGLSurface fghEGLPlatformOpenWindow( EGLNativeWindowType handle ); + +/* + * Opens a window. Requires a SFG_Window object created and attached + * to the freeglut structure. OpenGL context is created here. + */ +void fgPlatformOpenWindow( SFG_Window* window, const char* title, + GLboolean positionUse, int x, int y, + GLboolean sizeUse, int w, int h, + GLboolean gameMode, GLboolean isSubWindow ) +{ + printf("fgPlatformOpenWindow %p ID=%d\n", (void*)window, window->ID); + + /* TODO: only one full-screen window possible? */ + static int nb_windows = 0; + if (nb_windows == 0) { + nb_windows++; + fgDisplay.pDisplay.single_window = window; + printf("=> %p ID=%d\n", (void*)fgDisplay.pDisplay.single_window, fgDisplay.pDisplay.single_window->ID); + } else { + return; + } + + /* Wait until window is available and OpenGL context is created */ + /* Normally events are processed through glutMainLoop(), but the + user didn't call it yet, and the Android may not have initialized + the View yet. So we need to wait for that to happen. */ + /* We can't return from this function before the OpenGL context is + properly made current with a valid surface. So we wait for the + surface. */ + while (fgDisplay.pDisplay.single_window->Window.Handle == NULL) { + /* APP_CMD_INIT_WINDOW will do the job */ + fgPlatformProcessSingleEvent(); + } + + EGLDisplay display = fgDisplay.pDisplay.eglDisplay; + EGLint format = fgDisplay.pDisplay.eglContextFormat; + ANativeWindow_setBuffersGeometry(window->Window.Handle, 0, 0, format); + window->Window.pContext.eglSurface = fghEGLPlatformOpenWindow(window->Window.Handle); + + window->State.Visible = GL_TRUE; +} + +void fgPlatformSetWindow ( SFG_Window *window ) +{ + /* TODO: only a single window possible? */ +} + +/* + * This function makes the current window visible + */ +void fgPlatformGlutShowWindow( void ) +{ + fprintf(stderr, "fgPlatformGlutShowWindow: STUB\n"); +} + +/* + * This function hides the current window + */ +void fgPlatformGlutHideWindow( void ) +{ + fprintf(stderr, "fgPlatformGlutHideWindow: STUB\n"); +} + +/* + * Iconify the current window (top-level windows only) + */ +void fgPlatformGlutIconifyWindow( void ) +{ + fprintf(stderr, "fgPlatformGlutIconifyWindow: STUB\n"); +} + +/* + * Set the current window's title + */ +void fgPlatformGlutSetWindowTitle( const char* title ) +{ + fprintf(stderr, "fgPlatformGlutSetWindowTitle: STUB\n"); +} + +/* + * Set the current window's iconified title + */ +void fgPlatformGlutSetIconTitle( const char* title ) +{ + fprintf(stderr, "fgPlatformGlutSetIconTitle: STUB\n");} + +/* + * Change the current window's position + */ +void fgPlatformGlutPositionWindow( int x, int y ) +{ + fprintf(stderr, "fgPlatformGlutPositionWindow: STUB\n"); +} + +/* + * Lowers the current window (by Z order change) + */ +void fgPlatformGlutPushWindow( void ) +{ + fprintf(stderr, "fgPlatformGlutPushWindow: STUB\n"); +} + +/* + * Raises the current window (by Z order change) + */ +void fgPlatformGlutPopWindow( void ) +{ + fprintf(stderr, "fgPlatformGlutPopWindow: STUB\n"); +} + +/* + * Resize the current window so that it fits the whole screen + */ +void fgPlatformGlutFullScreen( SFG_Window *win ) +{ + fprintf(stderr, "fgPlatformGlutFullScreen: STUB\n"); +} + +/* + * If we are fullscreen, resize the current window back to its original size + */ +void fgPlatformGlutLeaveFullScreen( SFG_Window *win ) +{ + fprintf(stderr, "fgPlatformGlutLeaveFullScreen: STUB\n"); +} + +/* + * Toggle the window's full screen state. + */ +void fgPlatformGlutFullScreenToggle( SFG_Window *win ) +{ + fprintf(stderr, "fgPlatformGlutFullScreenToggle: STUB\n"); +} diff --git a/src/android/freeglut_gamemode_android.c b/src/android/freeglut_gamemode_android.c deleted file mode 100644 index d5f2316..0000000 --- a/src/android/freeglut_gamemode_android.c +++ /dev/null @@ -1,57 +0,0 @@ -/* - * freeglut_gamemode_x11.c - * - * The game mode handling code. - * - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#include -#include "../Common/freeglut_internal.h" - -/* - * Changes the current display mode to match user's settings - */ -GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest ) -{ - fprintf(stderr, "fgPlatformChangeDisplayMode: STUB\n"); - return GL_FALSE; -} - -void fgPlatformEnterGameMode( void ) -{ - fprintf(stderr, "fgPlatformEnterGameMode: STUB\n"); -} - -void fgPlatformRememberState( void ) -{ - fprintf(stderr, "fgPlatformRememberState: STUB\n"); -} - -void fgPlatformRestoreState( void ) -{ - fprintf(stderr, "fgPlatformRestoreState: STUB\n"); -} - -void fgPlatformLeaveGameMode( void ) -{ - fprintf(stderr, "fgPlatformLeaveGameMode: STUB\n"); -} - diff --git a/src/android/freeglut_input_devices_android.c b/src/android/freeglut_input_devices_android.c deleted file mode 100644 index 41f900d..0000000 --- a/src/android/freeglut_input_devices_android.c +++ /dev/null @@ -1,69 +0,0 @@ -/* - * freeglut_input_devices_android.c - * - * Handles miscellaneous input devices via direct serial-port access. - * - * Written by Joe Krahn 2005 - * Copyright (c) 2005 Stephen J. Baker. All Rights Reserved. - * Copied for Platform code by Evan Felix - * Copyright 2012 (C) Sylvain Beucler - * Creation date: Thur Feb 2 2012 - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA OR STEPHEN J. BAKER 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 SOFTWARE OR THE USE OR OTHER - * DEALINGS IN THE SOFTWARE. - */ - -#include -#include "../Common/freeglut_internal.h" -typedef struct _serialport SERIALPORT; - -/* - * Try initializing the input device(s) - */ -void fgPlatformRegisterDialDevice ( const char *dial_device ) -{ - fprintf(stderr, "fgPlatformRegisterDialDevice: STUB\n"); -} - -SERIALPORT *serial_open ( const char *device ) -{ - fprintf(stderr, "serial_open: STUB\n"); - return NULL; -} - -void serial_close(SERIALPORT *port) -{ - fprintf(stderr, "serial_close: STUB\n"); -} - -int serial_getchar(SERIALPORT *port) -{ - fprintf(stderr, "serial_getchar: STUB\n"); - return EOF; -} - -int serial_putchar(SERIALPORT *port, unsigned char ch) -{ - fprintf(stderr, "serial_putchar: STUB\n"); - return 0; -} - -void serial_flush ( SERIALPORT *port ) -{ - fprintf(stderr, "serial_flush: STUB\n"); -} diff --git a/src/android/freeglut_internal_android.h b/src/android/freeglut_internal_android.h deleted file mode 100644 index 8396ccc..0000000 --- a/src/android/freeglut_internal_android.h +++ /dev/null @@ -1,86 +0,0 @@ -/* - * freeglut_internal_android.h - * - * The freeglut library private include file. - * - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#ifndef FREEGLUT_INTERNAL_ANDROID_H -#define FREEGLUT_INTERNAL_ANDROID_H - - -/* -- PLATFORM-SPECIFIC INCLUDES ------------------------------------------- */ -/* Android OpenGL ES is accessed through EGL */ -#include "../egl/freeglut_internal_egl.h" - -/** - * Virtual PAD (spots on touchscreen that simulate keys) - */ -struct vpad_state { - bool on; - bool left; - bool right; - bool up; - bool down; -}; -struct touchscreen { - struct vpad_state vpad; - bool in_mmotion; -}; - - -/* -- JOYSTICK-SPECIFIC STRUCTURES AND TYPES ------------------------------- */ -/* - * Initial defines from "js.h" starting around line 33 with the existing "freeglut_joystick.c" - * interspersed - */ - - /* - * We'll put these values in and that should - * allow the code to at least compile when there is - * no support. The JS open routine should error out - * and shut off all the code downstream anyway and if - * the application doesn't use a joystick we'll be fine. - */ - - struct JS_DATA_TYPE - { - int buttons; - int x; - int y; - }; - -# define JS_RETURN (sizeof(struct JS_DATA_TYPE)) - -/* XXX It might be better to poll the operating system for the numbers of buttons and - * XXX axes and then dynamically allocate the arrays. - */ -# define _JS_MAX_AXES 16 -typedef struct tagSFG_PlatformJoystick SFG_PlatformJoystick; -struct tagSFG_PlatformJoystick -{ - struct JS_DATA_TYPE js; - - char fname [ 128 ]; - int fd; -}; - -#endif /* FREEGLUT_INTERNAL_ANDROID_H */ diff --git a/src/android/freeglut_joystick_android.c b/src/android/freeglut_joystick_android.c deleted file mode 100644 index e3a5059..0000000 --- a/src/android/freeglut_joystick_android.c +++ /dev/null @@ -1,50 +0,0 @@ -/* - * freeglut_joystick_android.c - * - * Joystick handling code - * - * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved. - * Written by Steve Baker, - * Copied for Platform code by Evan Felix - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#include -#include "../Common/freeglut_internal.h" - -void fgPlatformJoystickRawRead( SFG_Joystick* joy, int* buttons, float* axes ) -{ - fprintf(stderr, "fgPlatformJoystickRawRead: STUB\n"); -} - -void fgPlatformJoystickOpen( SFG_Joystick* joy ) -{ - fprintf(stderr, "fgPlatformJoystickOpen: STUB\n"); -} - -void fgPlatformJoystickInit( SFG_Joystick *fgJoystick[], int ident ) -{ - fprintf(stderr, "fgJoystick: STUB\n"); -} - -void fgPlatformJoystickClose ( int ident ) -{ - fprintf(stderr, "fgPlatformJoystickClose: STUB\n"); -} diff --git a/src/android/freeglut_main_android.c b/src/android/freeglut_main_android.c deleted file mode 100644 index a1a8451..0000000 --- a/src/android/freeglut_main_android.c +++ /dev/null @@ -1,403 +0,0 @@ -/* - * freeglut_main_android.c - * - * The Android-specific windows message processing methods. - * - * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved. - * Written by Pawel W. Olszta, - * Copied for Platform code by Evan Felix - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#include -#include "Common/freeglut_internal.h" - -#include -#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FreeGLUT", __VA_ARGS__)) -#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "FreeGLUT", __VA_ARGS__)) -#include -#include - -static struct touchscreen touchscreen; -static unsigned char key_a2fg[256]; - -/* Cf. http://developer.android.com/reference/android/view/KeyEvent.html */ -/* These codes are missing in */ -/* Don't convert to enum, since it may conflict with future version of - that */ -#define AKEYCODE_FORWARD_DEL 112 -#define AKEYCODE_CTRL_LEFT 113 -#define AKEYCODE_CTRL_RIGHT 114 -#define AKEYCODE_MOVE_HOME 122 -#define AKEYCODE_MOVE_END 123 -#define AKEYCODE_INSERT 124 -#define AKEYCODE_ESCAPE 127 -#define AKEYCODE_F1 131 -#define AKEYCODE_F2 132 -#define AKEYCODE_F3 133 -#define AKEYCODE_F4 134 -#define AKEYCODE_F5 135 -#define AKEYCODE_F6 136 -#define AKEYCODE_F7 137 -#define AKEYCODE_F8 138 -#define AKEYCODE_F9 139 -#define AKEYCODE_F10 140 -#define AKEYCODE_F11 141 -#define AKEYCODE_F12 142 - -#define EVENT_HANDLED 1 -#define EVENT_NOT_HANDLED 0 - -/** - * Initialize Android keycode to GLUT keycode mapping - */ -static void key_init() { - memset(key_a2fg, 0, sizeof(key_a2fg)); - - key_a2fg[AKEYCODE_F1] = GLUT_KEY_F1; - key_a2fg[AKEYCODE_F2] = GLUT_KEY_F2; - key_a2fg[AKEYCODE_F3] = GLUT_KEY_F3; - key_a2fg[AKEYCODE_F4] = GLUT_KEY_F4; - key_a2fg[AKEYCODE_F5] = GLUT_KEY_F5; - key_a2fg[AKEYCODE_F6] = GLUT_KEY_F6; - key_a2fg[AKEYCODE_F7] = GLUT_KEY_F7; - key_a2fg[AKEYCODE_F8] = GLUT_KEY_F8; - key_a2fg[AKEYCODE_F9] = GLUT_KEY_F9; - key_a2fg[AKEYCODE_F10] = GLUT_KEY_F10; - key_a2fg[AKEYCODE_F11] = GLUT_KEY_F11; - key_a2fg[AKEYCODE_F12] = GLUT_KEY_F12; - - key_a2fg[AKEYCODE_PAGE_UP] = GLUT_KEY_PAGE_UP; - key_a2fg[AKEYCODE_PAGE_DOWN] = GLUT_KEY_PAGE_DOWN; - key_a2fg[AKEYCODE_MOVE_HOME] = GLUT_KEY_HOME; - key_a2fg[AKEYCODE_MOVE_END] = GLUT_KEY_END; - key_a2fg[AKEYCODE_INSERT] = GLUT_KEY_INSERT; - - key_a2fg[AKEYCODE_DPAD_UP] = GLUT_KEY_UP; - key_a2fg[AKEYCODE_DPAD_DOWN] = GLUT_KEY_DOWN; - key_a2fg[AKEYCODE_DPAD_LEFT] = GLUT_KEY_LEFT; - key_a2fg[AKEYCODE_DPAD_RIGHT] = GLUT_KEY_RIGHT; - - key_a2fg[AKEYCODE_ALT_LEFT] = GLUT_KEY_ALT_L; - key_a2fg[AKEYCODE_ALT_RIGHT] = GLUT_KEY_ALT_R; - key_a2fg[AKEYCODE_SHIFT_LEFT] = GLUT_KEY_SHIFT_L; - key_a2fg[AKEYCODE_SHIFT_RIGHT] = GLUT_KEY_SHIFT_R; - key_a2fg[AKEYCODE_CTRL_LEFT] = GLUT_KEY_CTRL_L; - key_a2fg[AKEYCODE_CTRL_RIGHT] = GLUT_KEY_CTRL_R; -} - -/** - * Convert an Android key event to ASCII. - */ -static unsigned char key_ascii(struct android_app* app, AInputEvent* event) { - int32_t code = AKeyEvent_getKeyCode(event); - - /* Handle a few special cases: */ - switch (code) { - case AKEYCODE_DEL: - return 8; - case AKEYCODE_FORWARD_DEL: - return 127; - case AKEYCODE_ESCAPE: - return 27; - } - - /* Get usable JNI context */ - JNIEnv* env = app->activity->env; - JavaVM* vm = app->activity->vm; - (*vm)->AttachCurrentThread(vm, &env, NULL); - - jclass KeyEventClass = (*env)->FindClass(env, "android/view/KeyEvent"); - jmethodID KeyEventConstructor = (*env)->GetMethodID(env, KeyEventClass, "", "(II)V"); - jobject keyEvent = (*env)->NewObject(env, KeyEventClass, KeyEventConstructor, - AKeyEvent_getAction(event), AKeyEvent_getKeyCode(event)); - jmethodID KeyEvent_getUnicodeChar = (*env)->GetMethodID(env, KeyEventClass, "getUnicodeChar", "(I)I"); - int ascii = (*env)->CallIntMethod(env, keyEvent, KeyEvent_getUnicodeChar, AKeyEvent_getMetaState(event)); - - /* LOGI("getUnicodeChar(%d) = %d ('%c')", AKeyEvent_getKeyCode(event), ascii, ascii); */ - - return ascii; -} - -/* - * Handle a window configuration change. When no reshape - * callback is hooked, the viewport size is updated to - * match the new window size. - */ -void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height ) -{ - fprintf(stderr, "fgPlatformReshapeWindow: STUB\n"); -} - -/* - * A static helper function to execute display callback for a window - */ -void fgPlatformDisplayWindow ( SFG_Window *window ) -{ - fghRedrawWindow ( window ) ; -} - -unsigned long fgPlatformSystemTime ( void ) -{ - struct timeval now; - gettimeofday( &now, NULL ); - return now.tv_usec/1000 + now.tv_sec*1000; -} - -/* - * Does the magic required to relinquish the CPU until something interesting - * happens. - */ -void fgPlatformSleepForEvents( long msec ) -{ - /* fprintf(stderr, "fgPlatformSleepForEvents: STUB\n"); */ -} - -/** - * Process the next input event. - */ -int32_t handle_input(struct android_app* app, AInputEvent* event) { - SFG_Window* window = fgStructure.CurrentWindow; - - /* FIXME: in Android, when key is repeated, down and up events - happen most often at the exact same time. This makes it - impossible to animate based on key press time. */ - /* e.g. down/up/wait/down/up rather than down/wait/down/wait/up */ - - if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_KEY) { - /* LOGI("action: %d", AKeyEvent_getAction(event)); */ - /* LOGI("keycode: %d", code); */ - int32_t code = AKeyEvent_getKeyCode(event); - - if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_DOWN) { - int32_t keypress = 0; - unsigned char ascii = 0; - if ((keypress = key_a2fg[code]) && FETCH_WCB(*window, Special)) { - INVOKE_WCB(*window, Special, (keypress, window->State.MouseX, window->State.MouseY)); - return EVENT_HANDLED; - } else if ((ascii = key_ascii(app, event)) && FETCH_WCB(*window, Keyboard)) { - INVOKE_WCB(*window, Keyboard, (ascii, window->State.MouseX, window->State.MouseY)); - return EVENT_HANDLED; - } - } - else if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_UP) { - int32_t keypress = 0; - unsigned char ascii = 0; - if ((keypress = key_a2fg[code]) && FETCH_WCB(*window, Special)) { - INVOKE_WCB(*window, SpecialUp, (keypress, window->State.MouseX, window->State.MouseY)); - return EVENT_HANDLED; - } else if ((ascii = key_ascii(app, event)) && FETCH_WCB(*window, Keyboard)) { - INVOKE_WCB(*window, KeyboardUp, (ascii, window->State.MouseX, window->State.MouseY)); - return EVENT_HANDLED; - } - } - } - - if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) { - int32_t action = AMotionEvent_getAction(event); - float x = AMotionEvent_getX(event, 0); - float y = AMotionEvent_getY(event, 0); - LOGI("motion %.01f,%.01f action=%d", x, y, AMotionEvent_getAction(event)); - - /* Virtual arrows PAD */ - // Don't interfere with existing mouse move event - if (!touchscreen.in_mmotion) { - struct vpad_state prev_vpad = touchscreen.vpad; - touchscreen.vpad.left = touchscreen.vpad.right - = touchscreen.vpad.up = touchscreen.vpad.down = false; - - int32_t width = ANativeWindow_getWidth(window->Window.Handle); - int32_t height = ANativeWindow_getHeight(window->Window.Handle); - if (action == AMOTION_EVENT_ACTION_DOWN || action == AMOTION_EVENT_ACTION_MOVE) { - if ((x > 0 && x < 100) && (y > (height - 100) && y < height)) - touchscreen.vpad.left = true; - if ((x > 200 && x < 300) && (y > (height - 100) && y < height)) - touchscreen.vpad.right = true; - if ((x > 100 && x < 200) && (y > (height - 100) && y < height)) - touchscreen.vpad.down = true; - if ((x > 100 && x < 200) && (y > (height - 200) && y < (height - 100))) - touchscreen.vpad.up = true; - } - if (action == AMOTION_EVENT_ACTION_DOWN && - (touchscreen.vpad.left || touchscreen.vpad.right || touchscreen.vpad.down || touchscreen.vpad.up)) - touchscreen.vpad.on = true; - if (action == AMOTION_EVENT_ACTION_UP) - touchscreen.vpad.on = false; - if (prev_vpad.left != touchscreen.vpad.left - || prev_vpad.right != touchscreen.vpad.right - || prev_vpad.up != touchscreen.vpad.up - || prev_vpad.down != touchscreen.vpad.down - || prev_vpad.on != touchscreen.vpad.on) { - if (FETCH_WCB(*window, Special)) { - if (prev_vpad.left == false && touchscreen.vpad.left == true) - INVOKE_WCB(*window, Special, (GLUT_KEY_LEFT, x, y)); - else if (prev_vpad.right == false && touchscreen.vpad.right == true) - INVOKE_WCB(*window, Special, (GLUT_KEY_RIGHT, x, y)); - else if (prev_vpad.up == false && touchscreen.vpad.up == true) - INVOKE_WCB(*window, Special, (GLUT_KEY_UP, x, y)); - else if (prev_vpad.down == false && touchscreen.vpad.down == true) - INVOKE_WCB(*window, Special, (GLUT_KEY_DOWN, x, y)); - } - if (FETCH_WCB(*window, SpecialUp)) { - if (prev_vpad.left == true && touchscreen.vpad.left == false) - INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_LEFT, x, y)); - if (prev_vpad.right == true && touchscreen.vpad.right == false) - INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_RIGHT, x, y)); - if (prev_vpad.up == true && touchscreen.vpad.up == false) - INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_UP, x, y)); - if (prev_vpad.down == true && touchscreen.vpad.down == false) - INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_DOWN, x, y)); - } - return EVENT_HANDLED; - } - } - - /* Normal mouse events */ - if (!touchscreen.vpad.on) { - window->State.MouseX = x; - window->State.MouseY = y; - LOGI("Changed mouse position: %d,%d", x, y); - if (action == AMOTION_EVENT_ACTION_DOWN && FETCH_WCB(*window, Mouse)) { - touchscreen.in_mmotion = true; - INVOKE_WCB(*window, Mouse, (GLUT_LEFT_BUTTON, GLUT_DOWN, x, y)); - } else if (action == AMOTION_EVENT_ACTION_UP && FETCH_WCB(*window, Mouse)) { - touchscreen.in_mmotion = false; - INVOKE_WCB(*window, Mouse, (GLUT_LEFT_BUTTON, GLUT_UP, x, y)); - } else if (action == AMOTION_EVENT_ACTION_MOVE && FETCH_WCB(*window, Motion)) { - INVOKE_WCB(*window, Motion, (x, y)); - } - } - - return EVENT_HANDLED; - } - - /* Let Android handle other events (e.g. Back and Menu buttons) */ - return EVENT_NOT_HANDLED; -} - -/** - * Process the next main command. - */ -void handle_cmd(struct android_app* app, int32_t cmd) { - switch (cmd) { - case APP_CMD_SAVE_STATE: - /* The system has asked us to save our current state. Do so. */ - LOGI("handle_cmd: APP_CMD_SAVE_STATE"); - break; - case APP_CMD_INIT_WINDOW: - /* The window is being shown, get it ready. */ - LOGI("handle_cmd: APP_CMD_INIT_WINDOW"); - fgDisplay.pDisplay.single_window->Window.Handle = app->window; - /* glPlatformOpenWindow was waiting for Handle to be defined and - will now return from fgPlatformProcessSingleEvent() */ - break; - case APP_CMD_TERM_WINDOW: - /* The window is being hidden or closed, clean it up. */ - LOGI("handle_cmd: APP_CMD_TERM_WINDOW"); - fgDestroyWindow(fgDisplay.pDisplay.single_window); - break; - case APP_CMD_DESTROY: - /* Not reached because GLUT exit()s when last window is closed */ - LOGI("handle_cmd: APP_CMD_DESTROY"); - break; - case APP_CMD_GAINED_FOCUS: - LOGI("handle_cmd: APP_CMD_GAINED_FOCUS"); - break; - case APP_CMD_LOST_FOCUS: - LOGI("handle_cmd: APP_CMD_LOST_FOCUS"); - break; - case APP_CMD_CONFIG_CHANGED: - /* Handle rotation / orientation change */ - LOGI("handle_cmd: APP_CMD_CONFIG_CHANGED"); - break; - case APP_CMD_WINDOW_RESIZED: - LOGI("handle_cmd: APP_CMD_WINDOW_RESIZED"); - if (fgDisplay.pDisplay.single_window->Window.pContext.eglSurface != EGL_NO_SURFACE) - /* Make ProcessSingleEvent detect the new size, only available - after the next SwapBuffer */ - glutPostRedisplay(); - break; - default: - LOGI("handle_cmd: unhandled cmd=%d", cmd); - } -} - -void fgPlatformProcessSingleEvent ( void ) -{ - static int32_t last_width = -1; - static int32_t last_height = -1; - - /* When the screen is resized, the window handle still points to the - old window until the next SwapBuffer, while it's crucial to set - the size (onShape) correctly before the next onDisplay callback. - Plus we don't know if the next SwapBuffer already occurred at the - time we process the event (e.g. during onDisplay). */ - /* So we do the check each time rather than on event. */ - /* Interestingly, on a Samsung Galaxy S/PowerVR SGX540 GPU/Android - 2.3, that next SwapBuffer is fake (but still necessary to get the - new size). */ - SFG_Window* window = fgDisplay.pDisplay.single_window; - if (window != NULL && window->Window.Handle != NULL) { - int32_t width = ANativeWindow_getWidth(window->Window.Handle); - int32_t height = ANativeWindow_getHeight(window->Window.Handle); - if (width != last_width || height != last_height) { - last_width = width; - last_height = height; - LOGI("width=%d, height=%d", width, height); - if( FETCH_WCB( *window, Reshape ) ) - INVOKE_WCB( *window, Reshape, ( width, height ) ); - else - glViewport( 0, 0, width, height ); - glutPostRedisplay(); - } - } - - /* Read pending event. */ - int ident; - int events; - struct android_poll_source* source; - /* This is called "ProcessSingleEvent" but this means we'd only - process ~60 (screen Hz) mouse events per second, plus other ports - are processing all events already. So let's process all pending - events. */ - /* if ((ident=ALooper_pollOnce(0, NULL, &events, (void**)&source)) >= 0) { */ - while ((ident=ALooper_pollAll(0, NULL, &events, (void**)&source)) >= 0) { - /* Process this event. */ - if (source != NULL) { - source->process(source->app, source); - } - } -} - -void fgPlatformMainLoopPreliminaryWork ( void ) -{ - printf("fgPlatformMainLoopPreliminaryWork\n"); - - key_init(); - - /* Make sure glue isn't stripped. */ - /* JNI entry points need to be bundled even when linking statically */ - app_dummy(); -} - -void fgPlatformDeinitialiseInputDevices ( void ) -{ - fprintf(stderr, "fgPlatformDeinitialiseInputDevices: STUB\n"); -} diff --git a/src/android/freeglut_runtime_android.c b/src/android/freeglut_runtime_android.c deleted file mode 100644 index e83c2d3..0000000 --- a/src/android/freeglut_runtime_android.c +++ /dev/null @@ -1,160 +0,0 @@ -/* - * freeglut_runtime_android.c - * - * Android runtime - * - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -/* Parts taken from Android NDK's 'native-activity' sample : */ -/* - * 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 -#include -#include -#include -#include -#include -#include -#include "android/native_app_glue/android_native_app_glue.h" - -#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FreeGLUT", __VA_ARGS__)) -#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "FreeGLUT", __VA_ARGS__)) - -/* Cf. freeglut_main_android.c */ -extern int32_t handle_input(struct android_app* app, AInputEvent* event); -extern void handle_cmd(struct android_app* app, int32_t cmd); - -extern int main(int argc, char* argv[]); - -/** NativeActivity Callbacks **/ -/* Caution: they are called in the native_activity thread, not the - FreeGLUT thread. Use android_app_write_cmd. */ - -/* Could be used instead of onNativeWindowRedrawNeeded */ -/* Deals with status bar presence */ -static void onContentRectChanged(ANativeActivity* activity, const ARect* rect) { - LOGI("onContentRectChanged: l=%d,t=%d,r=%d,b=%d", rect->left, rect->top, rect->right, rect->bottom); -} - -/* Bug: not called during a resize in android-9, only once on startup :/ */ -static void onNativeWindowResized(ANativeActivity* activity, ANativeWindow* window) { - LOGI("onNativeWindowResized: %p\n", (void*)activity); -} - -/* Called after a resize, compensate broken onNativeWindowResized */ -static void onNativeWindowRedrawNeeded(ANativeActivity* activity, ANativeWindow* window) { - LOGI("onNativeWindowRedrawNeeded: %p\n", (void*)activity); - struct android_app* app = (struct android_app*)activity->instance; - //if (fgDisplay.pDisplay.single_window->Window.pContext.eglSurface != EGL_NO_SURFACE) - android_app_write_cmd(app, APP_CMD_WINDOW_RESIZED); -} - -/** - * Extract all .apk assets to the application directory so they can be - * accessed using accessed. - * TODO: parse directories recursively - */ -static void extract_assets(struct android_app* app) { - /* Get usable JNI context */ - JNIEnv* env = app->activity->env; - JavaVM* vm = app->activity->vm; - (*vm)->AttachCurrentThread(vm, &env, NULL); - - { - /* Get a handle on our calling NativeActivity class */ - jclass activityClass = (*env)->GetObjectClass(env, app->activity->clazz); - - /* Get path to cache dir (/data/data/org.myapp/cache) */ - jmethodID getCacheDir = (*env)->GetMethodID(env, activityClass, "getCacheDir", "()Ljava/io/File;"); - jobject file = (*env)->CallObjectMethod(env, app->activity->clazz, getCacheDir); - jclass fileClass = (*env)->FindClass(env, "java/io/File"); - jmethodID getAbsolutePath = (*env)->GetMethodID(env, fileClass, "getAbsolutePath", "()Ljava/lang/String;"); - jstring jpath = (jstring)(*env)->CallObjectMethod(env, file, getAbsolutePath); - const char* app_dir = (*env)->GetStringUTFChars(env, jpath, NULL); - - /* chdir in the application cache directory */ - LOGI("app_dir: %s", app_dir); - chdir(app_dir); - (*env)->ReleaseStringUTFChars(env, jpath, app_dir); - - /* Pre-extract assets, to avoid Android-specific file opening */ - { - AAssetManager* mgr = app->activity->assetManager; - AAssetDir* assetDir = AAssetManager_openDir(mgr, ""); - const char* filename = (const char*)NULL; - while ((filename = AAssetDir_getNextFileName(assetDir)) != NULL) { - AAsset* asset = AAssetManager_open(mgr, filename, AASSET_MODE_STREAMING); - char buf[BUFSIZ]; - int nb_read = 0; - FILE* out = fopen(filename, "w"); - while ((nb_read = AAsset_read(asset, buf, BUFSIZ)) > 0) - fwrite(buf, nb_read, 1, out); - fclose(out); - AAsset_close(asset); - } - AAssetDir_close(assetDir); - } - } -} - -/** - * This is the main entry point of a native application that is using - * android_native_app_glue. It runs in its own thread, with its own - * event loop for receiving input events and doing other things. - */ -void android_main(struct android_app* app) { - LOGI("android_main"); - - // Register window resize callback - app->activity->callbacks->onNativeWindowResized = onNativeWindowResized; - app->activity->callbacks->onContentRectChanged = onContentRectChanged; - app->activity->callbacks->onNativeWindowRedrawNeeded = onNativeWindowRedrawNeeded; - - app->onAppCmd = handle_cmd; - app->onInputEvent = handle_input; - - extract_assets(app); - - /* Call user's main */ - { - char progname[5] = "self"; - char* argv[] = {progname, NULL}; - main(1, argv); - } - - LOGI("android_main: end"); - exit(0); -} diff --git a/src/android/freeglut_spaceball_android.c b/src/android/freeglut_spaceball_android.c deleted file mode 100644 index 860f3d7..0000000 --- a/src/android/freeglut_spaceball_android.c +++ /dev/null @@ -1,58 +0,0 @@ -/* - * freeglut_spaceball_android.c - * - * Spaceball support for Windows - * - * Copyright (c) 2012 Stephen J. Baker. All Rights Reserved. - * Written by Evan Felix - * Creation date: Sat Feb 4, 2012 - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ -/* - * This code is a very complicated way of doing nothing. - * But is needed for Android platform builds. - */ - -#include -#include "../Common/freeglut_internal.h" - -void fgPlatformInitializeSpaceball(void) -{ - return; -} - -void fgPlatformSpaceballClose(void) -{ - return; -} - -int fgPlatformHasSpaceball(void) -{ - return 0; -} - -int fgPlatformSpaceballNumButtons(void) -{ - return 0; -} - -void fgPlatformSpaceballSetWindow(SFG_Window *window) -{ - return; -} diff --git a/src/android/freeglut_state_android.c b/src/android/freeglut_state_android.c deleted file mode 100644 index 09b2f78..0000000 --- a/src/android/freeglut_state_android.c +++ /dev/null @@ -1,113 +0,0 @@ -/* - * freeglut_state_android.c - * - * Android-specific freeglut state query methods. - * - * Copyright (c) 2012 Stephen J. Baker. All Rights Reserved. - * Written by John F. Fay, - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#include -#include "../Common/freeglut_internal.h" - -#include - -int fgPlatformGlutGet ( GLenum eWhat ) -{ - fprintf(stderr, "fgPlatformGlutGet: STUB\n"); - - switch (eWhat) { - case GLUT_WINDOW_WIDTH: - case GLUT_WINDOW_HEIGHT: - { - if ( fgStructure.CurrentWindow == NULL ) - return 0; - int32_t width = ANativeWindow_getWidth(fgStructure.CurrentWindow->Window.Handle); - int32_t height = ANativeWindow_getHeight(fgStructure.CurrentWindow->Window.Handle); - switch ( eWhat ) - { - case GLUT_WINDOW_WIDTH: - return width; - case GLUT_WINDOW_HEIGHT: - return height; - } - } - } - return -1; -} - -int fgPlatformGlutDeviceGet ( GLenum eWhat ) -{ - fprintf(stderr, "fgPlatformGlutDeviceGet: STUB\n"); - return -1; -} - -int fgPlatformGlutLayerGet( GLenum eWhat ) -{ - /* - * This is easy as layers are not implemented ;-) - * - * XXX Can we merge the UNIX/X11 and WIN32 sections? Or - * XXX is overlay support planned? - */ - switch( eWhat ) - { - case GLUT_OVERLAY_POSSIBLE: - return 0; - - case GLUT_LAYER_IN_USE: - return GLUT_NORMAL; - - case GLUT_HAS_OVERLAY: - return 0; - - case GLUT_TRANSPARENT_INDEX: - /* - * Return just anything, which is always defined as zero - * - * XXX HUH? - */ - return 0; - - case GLUT_NORMAL_DAMAGED: - /* XXX Actually I do not know. Maybe. */ - return 0; - - case GLUT_OVERLAY_DAMAGED: - return -1; - - default: - fgWarning( "glutLayerGet(): missing enum handle %d", eWhat ); - break; - } - - /* And fail. That's good. Programs do love failing. */ - return -1; -} - - -int *fgPlatformGlutGetModeValues(GLenum eWhat, int *size) -{ - fprintf(stderr, "fgPlatformGlutGetModeValues: STUB\n"); - return NULL; -} - - diff --git a/src/android/freeglut_window_android.c b/src/android/freeglut_window_android.c deleted file mode 100644 index 70388aa..0000000 --- a/src/android/freeglut_window_android.c +++ /dev/null @@ -1,165 +0,0 @@ -/* - * freeglut_window_android.c - * - * Window management methods for Android - * - * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved. - * Written by Pawel W. Olszta, - * Copied for Platform code by Evan Felix - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#define FREEGLUT_BUILDING_LIB -#include -#include "../Common/freeglut_internal.h" -extern EGLSurface fghEGLPlatformOpenWindow( EGLNativeWindowType handle ); - -/* - * Opens a window. Requires a SFG_Window object created and attached - * to the freeglut structure. OpenGL context is created here. - */ -void fgPlatformOpenWindow( SFG_Window* window, const char* title, - GLboolean positionUse, int x, int y, - GLboolean sizeUse, int w, int h, - GLboolean gameMode, GLboolean isSubWindow ) -{ - printf("fgPlatformOpenWindow %p ID=%d\n", (void*)window, window->ID); - - /* TODO: only one full-screen window possible? */ - static int nb_windows = 0; - if (nb_windows == 0) { - nb_windows++; - fgDisplay.pDisplay.single_window = window; - printf("=> %p ID=%d\n", (void*)fgDisplay.pDisplay.single_window, fgDisplay.pDisplay.single_window->ID); - } else { - return; - } - - /* Wait until window is available and OpenGL context is created */ - /* Normally events are processed through glutMainLoop(), but the - user didn't call it yet, and the Android may not have initialized - the View yet. So we need to wait for that to happen. */ - /* We can't return from this function before the OpenGL context is - properly made current with a valid surface. So we wait for the - surface. */ - while (fgDisplay.pDisplay.single_window->Window.Handle == NULL) { - /* APP_CMD_INIT_WINDOW will do the job */ - fgPlatformProcessSingleEvent(); - } - - EGLDisplay display = fgDisplay.pDisplay.eglDisplay; - EGLint format = fgDisplay.pDisplay.eglContextFormat; - ANativeWindow_setBuffersGeometry(window->Window.Handle, 0, 0, format); - window->Window.pContext.eglSurface = fghEGLPlatformOpenWindow(window->Window.Handle); - - window->State.Visible = GL_TRUE; -} - -void fgPlatformSetWindow ( SFG_Window *window ) -{ - /* TODO: only a single window possible? */ -} - -/* - * This function makes the current window visible - */ -void fgPlatformGlutShowWindow( void ) -{ - fprintf(stderr, "fgPlatformGlutShowWindow: STUB\n"); -} - -/* - * This function hides the current window - */ -void fgPlatformGlutHideWindow( void ) -{ - fprintf(stderr, "fgPlatformGlutHideWindow: STUB\n"); -} - -/* - * Iconify the current window (top-level windows only) - */ -void fgPlatformGlutIconifyWindow( void ) -{ - fprintf(stderr, "fgPlatformGlutIconifyWindow: STUB\n"); -} - -/* - * Set the current window's title - */ -void fgPlatformGlutSetWindowTitle( const char* title ) -{ - fprintf(stderr, "fgPlatformGlutSetWindowTitle: STUB\n"); -} - -/* - * Set the current window's iconified title - */ -void fgPlatformGlutSetIconTitle( const char* title ) -{ - fprintf(stderr, "fgPlatformGlutSetIconTitle: STUB\n");} - -/* - * Change the current window's position - */ -void fgPlatformGlutPositionWindow( int x, int y ) -{ - fprintf(stderr, "fgPlatformGlutPositionWindow: STUB\n"); -} - -/* - * Lowers the current window (by Z order change) - */ -void fgPlatformGlutPushWindow( void ) -{ - fprintf(stderr, "fgPlatformGlutPushWindow: STUB\n"); -} - -/* - * Raises the current window (by Z order change) - */ -void fgPlatformGlutPopWindow( void ) -{ - fprintf(stderr, "fgPlatformGlutPopWindow: STUB\n"); -} - -/* - * Resize the current window so that it fits the whole screen - */ -void fgPlatformGlutFullScreen( SFG_Window *win ) -{ - fprintf(stderr, "fgPlatformGlutFullScreen: STUB\n"); -} - -/* - * If we are fullscreen, resize the current window back to its original size - */ -void fgPlatformGlutLeaveFullScreen( SFG_Window *win ) -{ - fprintf(stderr, "fgPlatformGlutLeaveFullScreen: STUB\n"); -} - -/* - * Toggle the window's full screen state. - */ -void fgPlatformGlutFullScreenToggle( SFG_Window *win ) -{ - fprintf(stderr, "fgPlatformGlutFullScreenToggle: STUB\n"); -} diff --git a/src/android/opengles_stubs.c b/src/android/opengles_stubs.c index 732652b..c8437ce 100644 --- a/src/android/opengles_stubs.c +++ b/src/android/opengles_stubs.c @@ -1,5 +1,5 @@ #include -#include "../Common/freeglut_internal.h" +#include "fg_internal.h" void fgDeactivateMenu( SFG_Window *window ) { fprintf(stderr, "fgDeactivateMenu: STUB\n"); diff --git a/src/egl/fg_display_egl.c b/src/egl/fg_display_egl.c new file mode 100644 index 0000000..260b6ab --- /dev/null +++ b/src/egl/fg_display_egl.c @@ -0,0 +1,36 @@ +/* + * freeglut_display_android.c + * + * Display message posting, context buffer swapping. + * + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include "fg_internal.h" + +#include +#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FreeGLUT", __VA_ARGS__)) + +void fgPlatformGlutSwapBuffers( SFG_PlatformDisplay *pDisplayPtr, SFG_Window* CurrentWindow ) +{ + /* LOGI("Swap!"); */ + eglSwapBuffers( pDisplayPtr->eglDisplay, CurrentWindow->Window.pContext.eglSurface ); +} diff --git a/src/egl/fg_init_egl.c b/src/egl/fg_init_egl.c new file mode 100644 index 0000000..a58812a --- /dev/null +++ b/src/egl/fg_init_egl.c @@ -0,0 +1,80 @@ +/* + * freeglut_init_android.c + * + * Various freeglut initialization functions. + * + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#define FREEGLUT_BUILDING_LIB +#include +#include "fg_internal.h" + +#include + +/* + * A call to this function should initialize all the display stuff... + */ +void fgPlatformInitialize( const char* displayName ) +{ + fprintf(stderr, "fgPlatformInitialize\n"); + fgState.Initialised = GL_TRUE; + + /* CreateDisplay */ + /* Using EGL_DEFAULT_DISPLAY, or a specific native display */ + EGLNativeDisplayType nativeDisplay = EGL_DEFAULT_DISPLAY; + fgDisplay.pDisplay.eglDisplay = eglGetDisplay(nativeDisplay); + + FREEGLUT_INTERNAL_ERROR_EXIT(fgDisplay.pDisplay.eglDisplay != EGL_NO_DISPLAY, + "No display available", "fgPlatformInitialize"); + if (!eglInitialize(fgDisplay.pDisplay.eglDisplay, NULL, NULL)) + fgError("eglInitialize: error %x\n", eglGetError()); + + /* CreateContext */ + fghCreateContext(); + + // fgDisplay.ScreenWidth = ...; + // fgDisplay.ScreenHeight = ...; + // fgDisplay.ScreenWidthMM = ...; + // fgDisplay.ScreenHeightMM = ...; +} + +void fgPlatformCloseDisplay ( void ) +{ + eglMakeCurrent(fgDisplay.pDisplay.eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + if (fgDisplay.pDisplay.eglContext != EGL_NO_CONTEXT) { + eglDestroyContext(fgDisplay.pDisplay.eglDisplay, fgDisplay.pDisplay.eglContext); + fgDisplay.pDisplay.eglContext = EGL_NO_CONTEXT; + } + + if (fgDisplay.pDisplay.eglDisplay != EGL_NO_DISPLAY) { + eglTerminate(fgDisplay.pDisplay.eglDisplay); + fgDisplay.pDisplay.eglDisplay = EGL_NO_DISPLAY; + } +} + +/** + * Destroy a menu context + */ +void fgPlatformDestroyContext ( SFG_PlatformDisplay pDisplay, SFG_WindowContextType MContext ) +{ + if (MContext != EGL_NO_CONTEXT) + eglDestroyContext(pDisplay.eglDisplay, MContext); +} diff --git a/src/egl/fg_internal_egl.h b/src/egl/fg_internal_egl.h new file mode 100644 index 0000000..1a4def8 --- /dev/null +++ b/src/egl/fg_internal_egl.h @@ -0,0 +1,68 @@ +/* + * freeglut_internal_android.h + * + * The freeglut library private include file. + * + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef FREEGLUT_INTERNAL_EGL_H +#define FREEGLUT_INTERNAL_EGL_H + +#include + +/* -- GLOBAL TYPE DEFINITIONS ---------------------------------------------- */ +/* The structure used by display initialization in freeglut_init.c */ +typedef struct tagSFG_PlatformDisplay SFG_PlatformDisplay; +struct tagSFG_Window; +struct tagSFG_PlatformDisplay +{ + /* Used to initialize and deinitialize EGL */ + EGLDisplay eglDisplay; + EGLContext eglContext; + EGLConfig eglContextConfig; + EGLint eglContextFormat; + struct tagSFG_Window* single_window; +}; + + +/* + * Make "freeglut" window handle and context types so that we don't need so + * much conditionally-compiled code later in the library. + */ +typedef EGLNativeWindowType SFG_WindowHandleType ; +typedef EGLContext SFG_WindowContextType ; +typedef struct tagSFG_PlatformContext SFG_PlatformContext; +/* SFG_PlatformContext is used for SFG_Window.Window */ +struct tagSFG_PlatformContext +{ + EGLSurface eglSurface; +}; + + +/* Window's state description. This structure should be kept portable. */ +typedef struct tagSFG_PlatformWindowState SFG_PlatformWindowState; +struct tagSFG_PlatformWindowState +{ + int OldWidth; /* Window width from before a resize */ + int OldHeight; /* " height " " " " */ +}; + +#endif diff --git a/src/egl/fg_structure_egl.c b/src/egl/fg_structure_egl.c new file mode 100644 index 0000000..0466bc8 --- /dev/null +++ b/src/egl/fg_structure_egl.c @@ -0,0 +1,34 @@ +/* + * freeglut_structure_egl.c + * + * Windows and menus need tree structure + * + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include "fg_internal.h" + +extern SFG_Structure fgStructure; + +void fgPlatformCreateWindow ( SFG_Window *window ) +{ + window->Window.pContext.eglSurface = EGL_NO_SURFACE; +} diff --git a/src/egl/fg_window_egl.c b/src/egl/fg_window_egl.c new file mode 100644 index 0000000..6b980bd --- /dev/null +++ b/src/egl/fg_window_egl.c @@ -0,0 +1,129 @@ +/* + * freeglut_display_android.c + * + * Window management methods for EGL + * + * Copyright (C) 2012 Sylvain Beucler + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is 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 Software. + * + * THE SOFTWARE IS 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 + * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include "fg_internal.h" + +/** + * Initialize an EGL context for the current display. + */ +void fghCreateContext( ) { + /* + * 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 + */ + /* Ensure OpenGLES 2.0 context */ + printf("DisplayMode: %d (DEPTH %d)\n", fgState.DisplayMode, (fgState.DisplayMode & GLUT_DEPTH)); + const EGLint attribs[] = { + EGL_SURFACE_TYPE, EGL_WINDOW_BIT, + EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, + EGL_BLUE_SIZE, 1, + EGL_GREEN_SIZE, 1, + EGL_RED_SIZE, 1, + EGL_ALPHA_SIZE, (fgState.DisplayMode & GLUT_ALPHA) ? 1 : 0, + EGL_DEPTH_SIZE, (fgState.DisplayMode & GLUT_DEPTH) ? 1 : 0, + EGL_STENCIL_SIZE, (fgState.DisplayMode & GLUT_STENCIL) ? 1 : 0, + EGL_SAMPLE_BUFFERS, (fgState.DisplayMode & GLUT_MULTISAMPLE) ? 1 : 0, + EGL_SAMPLES, (fgState.DisplayMode & GLUT_MULTISAMPLE) ? fgState.SampleNumber : 0, + EGL_NONE + }; + + EGLint format; + EGLint numConfigs; + EGLConfig config; + EGLContext context; + + EGLDisplay eglDisplay = fgDisplay.pDisplay.eglDisplay; + + /* TODO : apply DisplayMode */ + /* (GLUT_DEPTH already applied in attribs[] above) */ + + /* Here, the application chooses the configuration it desires. In this + * sample, we have a very simplified selection process, where we pick + * the first EGLConfig that matches our criteria */ + eglChooseConfig(eglDisplay, attribs, &config, 1, &numConfigs); + + /* EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is + * guaranteed to be accepted by ANativeWindow_setBuffersGeometry(). + * As soon as we picked a EGLConfig, we can safely reconfigure the + * ANativeWindow buffers to match, using EGL_NATIVE_VISUAL_ID. */ + eglGetConfigAttrib(eglDisplay, config, EGL_NATIVE_VISUAL_ID, &format); + + /* Default, but doesn't hurt */ + eglBindAPI(EGL_OPENGL_ES_API); + + /* Ensure OpenGLES 2.0 context */ + static const EGLint ctx_attribs[] = { + EGL_CONTEXT_CLIENT_VERSION, 2, + EGL_NONE + }; + context = eglCreateContext(eglDisplay, config, EGL_NO_CONTEXT, ctx_attribs); + if (context == EGL_NO_CONTEXT) { + fgWarning("Cannot initialize EGL context, err=%x\n", eglGetError()); + fghContextCreationError(); + } + EGLint ver = -1; + eglQueryContext(fgDisplay.pDisplay.eglDisplay, context, EGL_CONTEXT_CLIENT_VERSION, &ver); + if (ver != 2) + fgError("Wrong GLES major version: %d\n", ver); + + fgDisplay.pDisplay.eglContext = context; + fgDisplay.pDisplay.eglContextConfig = config; + fgDisplay.pDisplay.eglContextFormat = format; +} + +/* + * Really opens a window when handle is available + */ +EGLSurface fghEGLPlatformOpenWindow( EGLNativeWindowType handle ) +{ + EGLDisplay display = fgDisplay.pDisplay.eglDisplay; + EGLContext context = fgDisplay.pDisplay.eglContext; + EGLConfig config = fgDisplay.pDisplay.eglContextConfig; + + EGLSurface surface = eglCreateWindowSurface(display, config, handle, NULL); + if (surface == EGL_NO_SURFACE) + fgError("Cannot create EGL window surface, err=%x\n", eglGetError()); + if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) + fgError("eglMakeCurrent: err=%x\n", eglGetError()); + + //EGLint w, h; + //eglQuerySurface(display, surface, EGL_WIDTH, &w); + //eglQuerySurface(display, surface, EGL_HEIGHT, &h); + + return surface; +} + +/* + * Closes a window, destroying the frame and OpenGL context + */ +void fgPlatformCloseWindow( SFG_Window* window ) +{ + if (window->Window.pContext.eglSurface != EGL_NO_SURFACE) { + eglDestroySurface(fgDisplay.pDisplay.eglDisplay, window->Window.pContext.eglSurface); + window->Window.pContext.eglSurface = EGL_NO_SURFACE; + } +} diff --git a/src/egl/freeglut_display_egl.c b/src/egl/freeglut_display_egl.c deleted file mode 100644 index 1a25362..0000000 --- a/src/egl/freeglut_display_egl.c +++ /dev/null @@ -1,36 +0,0 @@ -/* - * freeglut_display_android.c - * - * Display message posting, context buffer swapping. - * - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#include -#include "../Common/freeglut_internal.h" - -#include -#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FreeGLUT", __VA_ARGS__)) - -void fgPlatformGlutSwapBuffers( SFG_PlatformDisplay *pDisplayPtr, SFG_Window* CurrentWindow ) -{ - /* LOGI("Swap!"); */ - eglSwapBuffers( pDisplayPtr->eglDisplay, CurrentWindow->Window.pContext.eglSurface ); -} diff --git a/src/egl/freeglut_init_egl.c b/src/egl/freeglut_init_egl.c deleted file mode 100644 index 9d03349..0000000 --- a/src/egl/freeglut_init_egl.c +++ /dev/null @@ -1,80 +0,0 @@ -/* - * freeglut_init_android.c - * - * Various freeglut initialization functions. - * - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#define FREEGLUT_BUILDING_LIB -#include -#include "../Common/freeglut_internal.h" - -#include - -/* - * A call to this function should initialize all the display stuff... - */ -void fgPlatformInitialize( const char* displayName ) -{ - fprintf(stderr, "fgPlatformInitialize\n"); - fgState.Initialised = GL_TRUE; - - /* CreateDisplay */ - /* Using EGL_DEFAULT_DISPLAY, or a specific native display */ - EGLNativeDisplayType nativeDisplay = EGL_DEFAULT_DISPLAY; - fgDisplay.pDisplay.eglDisplay = eglGetDisplay(nativeDisplay); - - FREEGLUT_INTERNAL_ERROR_EXIT(fgDisplay.pDisplay.eglDisplay != EGL_NO_DISPLAY, - "No display available", "fgPlatformInitialize"); - if (!eglInitialize(fgDisplay.pDisplay.eglDisplay, NULL, NULL)) - fgError("eglInitialize: error %x\n", eglGetError()); - - /* CreateContext */ - fghCreateContext(); - - // fgDisplay.ScreenWidth = ...; - // fgDisplay.ScreenHeight = ...; - // fgDisplay.ScreenWidthMM = ...; - // fgDisplay.ScreenHeightMM = ...; -} - -void fgPlatformCloseDisplay ( void ) -{ - eglMakeCurrent(fgDisplay.pDisplay.eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); - if (fgDisplay.pDisplay.eglContext != EGL_NO_CONTEXT) { - eglDestroyContext(fgDisplay.pDisplay.eglDisplay, fgDisplay.pDisplay.eglContext); - fgDisplay.pDisplay.eglContext = EGL_NO_CONTEXT; - } - - if (fgDisplay.pDisplay.eglDisplay != EGL_NO_DISPLAY) { - eglTerminate(fgDisplay.pDisplay.eglDisplay); - fgDisplay.pDisplay.eglDisplay = EGL_NO_DISPLAY; - } -} - -/** - * Destroy a menu context - */ -void fgPlatformDestroyContext ( SFG_PlatformDisplay pDisplay, SFG_WindowContextType MContext ) -{ - if (MContext != EGL_NO_CONTEXT) - eglDestroyContext(pDisplay.eglDisplay, MContext); -} diff --git a/src/egl/freeglut_internal_egl.h b/src/egl/freeglut_internal_egl.h deleted file mode 100644 index 1a4def8..0000000 --- a/src/egl/freeglut_internal_egl.h +++ /dev/null @@ -1,68 +0,0 @@ -/* - * freeglut_internal_android.h - * - * The freeglut library private include file. - * - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#ifndef FREEGLUT_INTERNAL_EGL_H -#define FREEGLUT_INTERNAL_EGL_H - -#include - -/* -- GLOBAL TYPE DEFINITIONS ---------------------------------------------- */ -/* The structure used by display initialization in freeglut_init.c */ -typedef struct tagSFG_PlatformDisplay SFG_PlatformDisplay; -struct tagSFG_Window; -struct tagSFG_PlatformDisplay -{ - /* Used to initialize and deinitialize EGL */ - EGLDisplay eglDisplay; - EGLContext eglContext; - EGLConfig eglContextConfig; - EGLint eglContextFormat; - struct tagSFG_Window* single_window; -}; - - -/* - * Make "freeglut" window handle and context types so that we don't need so - * much conditionally-compiled code later in the library. - */ -typedef EGLNativeWindowType SFG_WindowHandleType ; -typedef EGLContext SFG_WindowContextType ; -typedef struct tagSFG_PlatformContext SFG_PlatformContext; -/* SFG_PlatformContext is used for SFG_Window.Window */ -struct tagSFG_PlatformContext -{ - EGLSurface eglSurface; -}; - - -/* Window's state description. This structure should be kept portable. */ -typedef struct tagSFG_PlatformWindowState SFG_PlatformWindowState; -struct tagSFG_PlatformWindowState -{ - int OldWidth; /* Window width from before a resize */ - int OldHeight; /* " height " " " " */ -}; - -#endif diff --git a/src/egl/freeglut_structure_egl.c b/src/egl/freeglut_structure_egl.c deleted file mode 100644 index b465f1e..0000000 --- a/src/egl/freeglut_structure_egl.c +++ /dev/null @@ -1,34 +0,0 @@ -/* - * freeglut_structure_egl.c - * - * Windows and menus need tree structure - * - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#include -#include "../Common/freeglut_internal.h" - -extern SFG_Structure fgStructure; - -void fgPlatformCreateWindow ( SFG_Window *window ) -{ - window->Window.pContext.eglSurface = EGL_NO_SURFACE; -} diff --git a/src/egl/freeglut_window_egl.c b/src/egl/freeglut_window_egl.c deleted file mode 100644 index b2e70b7..0000000 --- a/src/egl/freeglut_window_egl.c +++ /dev/null @@ -1,129 +0,0 @@ -/* - * freeglut_display_android.c - * - * Window management methods for EGL - * - * Copyright (C) 2012 Sylvain Beucler - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is 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 Software. - * - * THE SOFTWARE IS 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 - * PAWEL W. OLSZTA 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#include -#include "../Common/freeglut_internal.h" - -/** - * Initialize an EGL context for the current display. - */ -void fghCreateContext( ) { - /* - * 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 - */ - /* Ensure OpenGLES 2.0 context */ - printf("DisplayMode: %d (DEPTH %d)\n", fgState.DisplayMode, (fgState.DisplayMode & GLUT_DEPTH)); - const EGLint attribs[] = { - EGL_SURFACE_TYPE, EGL_WINDOW_BIT, - EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, - EGL_BLUE_SIZE, 1, - EGL_GREEN_SIZE, 1, - EGL_RED_SIZE, 1, - EGL_ALPHA_SIZE, (fgState.DisplayMode & GLUT_ALPHA) ? 1 : 0, - EGL_DEPTH_SIZE, (fgState.DisplayMode & GLUT_DEPTH) ? 1 : 0, - EGL_STENCIL_SIZE, (fgState.DisplayMode & GLUT_STENCIL) ? 1 : 0, - EGL_SAMPLE_BUFFERS, (fgState.DisplayMode & GLUT_MULTISAMPLE) ? 1 : 0, - EGL_SAMPLES, (fgState.DisplayMode & GLUT_MULTISAMPLE) ? fgState.SampleNumber : 0, - EGL_NONE - }; - - EGLint format; - EGLint numConfigs; - EGLConfig config; - EGLContext context; - - EGLDisplay eglDisplay = fgDisplay.pDisplay.eglDisplay; - - /* TODO : apply DisplayMode */ - /* (GLUT_DEPTH already applied in attribs[] above) */ - - /* Here, the application chooses the configuration it desires. In this - * sample, we have a very simplified selection process, where we pick - * the first EGLConfig that matches our criteria */ - eglChooseConfig(eglDisplay, attribs, &config, 1, &numConfigs); - - /* EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is - * guaranteed to be accepted by ANativeWindow_setBuffersGeometry(). - * As soon as we picked a EGLConfig, we can safely reconfigure the - * ANativeWindow buffers to match, using EGL_NATIVE_VISUAL_ID. */ - eglGetConfigAttrib(eglDisplay, config, EGL_NATIVE_VISUAL_ID, &format); - - /* Default, but doesn't hurt */ - eglBindAPI(EGL_OPENGL_ES_API); - - /* Ensure OpenGLES 2.0 context */ - static const EGLint ctx_attribs[] = { - EGL_CONTEXT_CLIENT_VERSION, 2, - EGL_NONE - }; - context = eglCreateContext(eglDisplay, config, EGL_NO_CONTEXT, ctx_attribs); - if (context == EGL_NO_CONTEXT) { - fgWarning("Cannot initialize EGL context, err=%x\n", eglGetError()); - fghContextCreationError(); - } - EGLint ver = -1; - eglQueryContext(fgDisplay.pDisplay.eglDisplay, context, EGL_CONTEXT_CLIENT_VERSION, &ver); - if (ver != 2) - fgError("Wrong GLES major version: %d\n", ver); - - fgDisplay.pDisplay.eglContext = context; - fgDisplay.pDisplay.eglContextConfig = config; - fgDisplay.pDisplay.eglContextFormat = format; -} - -/* - * Really opens a window when handle is available - */ -EGLSurface fghEGLPlatformOpenWindow( EGLNativeWindowType handle ) -{ - EGLDisplay display = fgDisplay.pDisplay.eglDisplay; - EGLContext context = fgDisplay.pDisplay.eglContext; - EGLConfig config = fgDisplay.pDisplay.eglContextConfig; - - EGLSurface surface = eglCreateWindowSurface(display, config, handle, NULL); - if (surface == EGL_NO_SURFACE) - fgError("Cannot create EGL window surface, err=%x\n", eglGetError()); - if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) - fgError("eglMakeCurrent: err=%x\n", eglGetError()); - - //EGLint w, h; - //eglQuerySurface(display, surface, EGL_WIDTH, &w); - //eglQuerySurface(display, surface, EGL_HEIGHT, &h); - - return surface; -} - -/* - * Closes a window, destroying the frame and OpenGL context - */ -void fgPlatformCloseWindow( SFG_Window* window ) -{ - if (window->Window.pContext.eglSurface != EGL_NO_SURFACE) { - eglDestroySurface(fgDisplay.pDisplay.eglDisplay, window->Window.pContext.eglSurface); - window->Window.pContext.eglSurface = EGL_NO_SURFACE; - } -} -- 1.7.10.4