void QBBScreenEventThread::run()
{
screen_event_t event;
// create screen event
errno = 0;
int result = screen_create_event(&event);
if (result)
qFatal("QBB: failed to create screen event, errno=%d", errno);
#if defined(QBBSCREENEVENTTHREAD_DEBUG)
qDebug() << "QBB: screen event thread started";
#endif
// loop indefinitely
while (!mQuit) {
// block until screen event is available
errno = 0;
result = screen_get_event(mContext, event, -1);
if (result)
qFatal("QBB: failed to get screen event, errno=%d", errno);
// process received event
errno = 0;
int qnxType;
int result = screen_get_event_property_iv(event, SCREEN_PROPERTY_TYPE, &qnxType);
if (result)
qFatal("QBB: failed to query screen event type, errno=%d", errno);
if (qnxType == SCREEN_EVENT_USER) {
// treat all screen user events as shutdown requests
#if defined(QBBSCREENEVENTTHREAD_DEBUG)
qDebug() << "QBB: QNX screen user event";
#endif
mQuit = true;
} else {
mEventHandler->handleEvent(event, qnxType);
}
}
#if defined(QBBSCREENEVENTTHREAD_DEBUG)
qDebug() << "QBB: screen event thread stopped";
#endif
// cleanup
screen_destroy_event(event);
}
void QBBEventThread::shutdown()
{
screen_event_t event;
// create screen event
errno = 0;
int result = screen_create_event(&event);
if (result) {
qFatal("QBB: failed to create event, errno=%d", errno);
}
// set the event type as user
errno = 0;
int type = SCREEN_EVENT_USER;
result = screen_set_event_property_iv(event, SCREEN_PROPERTY_TYPE, &type);
if (result) {
qFatal("QBB: failed to set event type, errno=%d", errno);
}
// NOTE: ignore SCREEN_PROPERTY_USER_DATA; treat all user events as shutdown events
// post event to event loop so it will wake up and die
errno = 0;
result = screen_send_event(mContext, event, getpid());
if (result) {
qFatal("QBB: failed to set event type, errno=%d", errno);
}
// cleanup
screen_destroy_event(event);
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: event loop shutdown begin";
#endif
// block until thread terminates
wait();
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: event loop shutdown end";
#endif
}
void QBBEventThread::run()
{
screen_event_t event;
// create screen event
errno = 0;
int result = screen_create_event(&event);
if (result) {
qFatal("QBB: failed to create event, errno=%d", errno);
}
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: event loop started";
#endif
// loop indefinitely
while (!mQuit) {
// block until screen event is available
errno = 0;
result = screen_get_event(mContext, event, -1);
if (result) {
qFatal("QBB: failed to get event, errno=%d", errno);
}
// process received event
dispatchEvent(event);
}
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: event loop stopped";
#endif
// cleanup
screen_destroy_event(event);
}
int QNX_InitGL(void)
{
int usage = SCREEN_USAGE_OPENGL_ES1;
int transp = SCREEN_TRANSPARENCY_NONE;
EGLint interval = 1;
int size[2] = { -1, -1 };
int pos[2] = { 0, 0 };
int nbuffers = 2;
int format;
EGLConfig config;
EGLint err;
config = choose_config(eglDisplay, "rgb565");
if (config == (EGLConfig)0) {
Com_Printf( "Demo Thread Init: failed to find config!" );
return FALSE;
}
// Create EGL rendering context
eglContext = eglCreateContext( eglDisplay, config, EGL_NO_CONTEXT, NULL );
err = eglGetError( );
if ( eglContext == EGL_NO_CONTEXT ) {
Com_Printf( "Demo Thread Init: can't create gles2 context!" );
PrintEglError( err );
return FALSE;
}
err = screen_create_context(&screen_ctx, 0);
if (err) {
Com_Printf("screen_create_context");
return FALSE;
}
err = screen_create_window(&screen_win, screen_ctx);
if (err) {
Com_Printf("screen_create_window");
return FALSE;
}
format = choose_format(eglDisplay, config);
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_FORMAT, &format);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
return FALSE;
}
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
return FALSE;
}
size[0]=1024;
size[1]=768;
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (err) {
Com_Printf("screen_set_window_property_iv(screen_set_window_property_iv)");
return FALSE;
}
if (size[0] > 0 && size[1] > 0) {
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SIZE, size);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_SIZE)");
return FALSE;
}
} else {
err = screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_SIZE, size);
if (err) {
Com_Printf("screen_get_window_property_iv(SCREEN_PROPERTY_SIZE)");
return FALSE;
}
}
glConfig.vidWidth = size[0];
glConfig.vidHeight = size[1];
InitControls();
bz[0] = size[0];
bz[1] = size[1];
if (pos[0] != 0 || pos[1] != 0) {
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_POSITION, pos);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_POSITION)");
return FALSE;
}
}
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_TRANSPARENCY, &transp);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_TRANSPARENCY)");
return FALSE;
}
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SWAP_INTERVAL, &interval);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_SWAP_INTERVAL)");
return FALSE;
}
err = screen_create_window_buffers(screen_win, nbuffers);
if (err) {
Com_Printf("screen_create_window_buffers");
return FALSE;
}
size[0] = 1024;
size[1] = 600;
err = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_SIZE, size);
if (err) {
Com_Printf("screen_set_window_property_iv(SCREEN_PROPERTY_SIZE)");
return FALSE;
}
err = screen_create_event(&screen_ev);
if (err) {
Com_Printf("screen_create_event");
return FALSE;
}
eglSurface = eglCreateWindowSurface(eglDisplay, config, screen_win, NULL);
if (eglSurface == EGL_NO_SURFACE) {
Com_Printf( "Demo Thread Init: can't create surface!" );
PrintEglError( err );
return FALSE;
}
err = eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);
if (err != EGL_TRUE) {
Com_Printf( "Demo Thread Init: can't make current!" );
return FALSE;
}
pps_decoder_init(&decoder, NULL, 0);
ppsfd = open("/pps/services/navigator/control", O_RDWR);
if (ppsfd == -1) {
Com_Printf("warning: failed to open PPS\n");
}
return TRUE;
}
bool CCEGLView::initGL()
{
int rc = 0;
int screenFormat = SCREEN_FORMAT_RGBA8888;
#ifdef __X86__
int screenUsage = SCREEN_USAGE_OPENGL_ES2;
#else
int screenUsage = SCREEN_USAGE_DISPLAY|SCREEN_USAGE_OPENGL_ES2; // Physical device copy directly into physical display
#endif
// int screenSwapInterval = WINDOW_VSYNC ? 1 : 0;
int screenTransparency = SCREEN_TRANSPARENCY_NONE;
int angle = atoi(getenv("ORIENTATION"));
// Hard-coded to (0,0).
int windowPosition[] =
{
0, 0
};
EGLint eglConfigCount;
EGLConfig config;
// Hard-coded to 32-bit/OpenGL ES 2.0.
const EGLint eglConfigAttrs[] =
{
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 24,
EGL_STENCIL_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
const EGLint eglContextAttrs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
const EGLint eglSurfaceAttrs[] =
{
EGL_RENDER_BUFFER, EGL_BACK_BUFFER,
EGL_NONE
};
// Create the screen context.
rc = screen_create_context(&m_screenContext, 0);
if (rc)
{
perror("screen_create_context");
return false;
}
// Create the screen window.
rc = screen_create_window(&m_screenWindow, m_screenContext);
if (rc)
{
perror("screen_create_window");
return false;
}
// Set/get any window prooperties.
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_FORMAT, &screenFormat);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
return false;
}
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_USAGE, &screenUsage);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
return false;
}
char *width_str = getenv("WIDTH");
char *height_str = getenv("HEIGHT");
if (width_str && height_str)
{
int screen_res[2];
screen_res[0] = atoi(width_str);
screen_res[1] = atoi(height_str);
int rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, screen_res);
if (rc)
{
fprintf(stderr, "screen_set_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
return false;
}
}
else
{
screen_display_t screen_display;
rc = screen_get_window_property_pv(m_screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&screen_display);
if (rc)
{
perror("screen_get_window_property_pv(SCREEN_PROPERTY_DISPLAY)");
return false;
}
screen_display_mode_t screen_mode;
rc = screen_get_display_property_pv(screen_display, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
if (rc)
{
perror("screen_get_display_property_pv(SCREEN_PROPERTY_MODE)");
return false;
}
int size[2];
rc = screen_get_window_property_iv(m_screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc)
{
perror("screen_get_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
return false;
}
int buffer_size[2] = { size[0], size[1] };
if ((angle == 0) || (angle == 180))
{
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1])))
{
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
}
else if ((angle == 90) || (angle == 270))
{
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] < size[1])))
{
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
}
else
{
perror("Navigator returned an unexpected orientation angle.");
return false;
}
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_ROTATION, &angle);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_ROTATION)");
return false;
}
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
return false;
}
}
if (windowPosition[0] != 0 || windowPosition[1] != 0)
{
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_POSITION, windowPosition);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_POSITION)");
return false;
}
}
rc = screen_set_window_property_iv(m_screenWindow, SCREEN_PROPERTY_TRANSPARENCY, &screenTransparency);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_TRANSPARENCY)");
return false;
}
// Double buffered.
rc = screen_create_window_buffers(m_screenWindow, 2);
if (rc)
{
perror("screen_create_window_buffers");
return false;
}
// Create screen event object.
rc = screen_create_event(&m_screenEvent);
if (rc)
{
perror("screen_create_event");
return false;
}
// Request screen events.
screen_request_events(m_screenContext);
// Get the EGL display and initialize.
m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (m_eglDisplay == EGL_NO_DISPLAY)
{
perror("eglGetDisplay");
return false;
}
if (eglInitialize(m_eglDisplay, NULL, NULL) != EGL_TRUE)
{
perror("eglInitialize");
return false;
}
if (eglChooseConfig(m_eglDisplay, eglConfigAttrs, &config, 1, &eglConfigCount) != EGL_TRUE || eglConfigCount == 0)
{
checkErrorEGL("eglChooseConfig");
return false;
}
m_eglContext = eglCreateContext(m_eglDisplay, config, EGL_NO_CONTEXT, eglContextAttrs);
if (m_eglContext == EGL_NO_CONTEXT)
{
checkErrorEGL("eglCreateContext");
return false;
}
m_eglSurface = eglCreateWindowSurface(m_eglDisplay, config, m_screenWindow, eglSurfaceAttrs);
if (m_eglSurface == EGL_NO_SURFACE)
{
checkErrorEGL("eglCreateWindowSurface");
return false;
}
if (eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext) != EGL_TRUE)
{
checkErrorEGL("eglMakeCurrent");
return false;
}
EGLint width, height;
if ((m_eglDisplay == EGL_NO_DISPLAY) || (m_eglSurface == EGL_NO_SURFACE) )
return EXIT_FAILURE;
eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_WIDTH, &width);
eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_HEIGHT, &height);
m_obScreenSize.width = width;
m_obScreenSize.height = height;
// Set vsync.
// eglSwapInterval(m_eglDisplay, screenSwapInterval);
return true;
}
gceSTATUS
gcoOS_GetEvent(
IN HALNativeDisplayType Display,
IN HALNativeWindowType Window,
OUT halEvent * Event
)
{
screen_event_t screen_evt;
int rc;
gceSTATUS status = gcvSTATUS_NOT_FOUND;
rc = screen_create_event(&screen_evt);
while (screen_get_event(screen_ctx, screen_evt, 0L) == 0)
{
int type;
screen_get_event_property_iv(screen_evt, SCREEN_PROPERTY_TYPE, &type);
if (type == SCREEN_EVENT_CLOSE)
{
Event->type = HAL_CLOSE;
status = gcvSTATUS_OK;
break;
}
else if (type == SCREEN_EVENT_POINTER)
{
static int last_buttons;
int buttons;
int pointer[2];
screen_get_event_property_iv(screen_evt, SCREEN_PROPERTY_BUTTONS, &buttons);
screen_get_event_property_iv(screen_evt, SCREEN_PROPERTY_POSITION, pointer);
if (buttons != last_buttons)
{
Event->type = HAL_BUTTON;
Event->data.button.left = (buttons & 0x0001);
/* TODO
Event->data.button.middle = (buttons & 0x????);
Event->data.button.right = (buttons & 0x????);
*/
Event->data.button.x = pointer[0];
Event->data.button.y = pointer[1];
last_buttons = buttons;
}
else
{
Event->type = HAL_POINTER;
Event->data.pointer.x = pointer[0];
Event->data.pointer.y = pointer[1];
}
status = gcvSTATUS_OK;
break;
}
else if (type == SCREEN_EVENT_KEYBOARD)
{
int buffer;
int scancode;
static int prefix;
screen_get_event_property_iv(screen_evt, SCREEN_PROPERTY_KEY_SCAN, &buffer);
if ((buffer == 0xE0) || (buffer == 0xE1))
{
prefix = buffer;
continue;
}
if (prefix)
{
scancode = keys[buffer & 0x7F].extended;
prefix = 0;
}
else
{
scancode = keys[buffer & 0x7F].normal;
}
if (scancode == HAL_UNKNOWN)
{
continue;
}
Event->type = HAL_KEYBOARD;
Event->data.keyboard.scancode = scancode;
Event->data.keyboard.pressed = buffer < 0x80;
Event->data.keyboard.key = ( (scancode < HAL_SPACE)
|| (scancode >= HAL_F1)
)
? 0
: (char) scancode;
status = gcvSTATUS_OK;
break;
}
else if (type == SCREEN_EVENT_NONE)
{
break;
}
else
{
break;
}
}
screen_destroy_event(screen_evt);
return status;
}
int main(int argc, char **argv)
{
int pos[2] = {0, 0};
int size[2];
int vis = 1;
int type;
screen_create_context(&screen_ctx, SCREEN_APPLICATION_CONTEXT);
int count = 0;
screen_get_context_property_iv(screen_ctx, SCREEN_PROPERTY_DISPLAY_COUNT, &count);
screen_display_t *screen_disps = calloc(count, sizeof(screen_display_t));
screen_get_context_property_pv(screen_ctx, SCREEN_PROPERTY_DISPLAYS, (void **)screen_disps);
screen_display_t screen_disp = screen_disps[0];
free(screen_disps);
int dims[2] = { 0, 0 };
screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_SIZE, dims);
char str[16];
snprintf(str, sizeof(str), "%d", getpid());
screen_bg_win = create_bg_window(str, dims);
screen_bar_win = create_bar_window(str, bar_id_string, dims);
screen_hg_win = create_hg_window(str, hg_id_string, dims);
if ( create_gles_window(str, gles_id_string, dims) != EXIT_SUCCESS){
fprintf(stderr, "Could not initialize OpenGL window. Exiting...\n");
screen_destroy_context(screen_ctx);
return EXIT_FAILURE;
}
screen_event_t screen_ev;
screen_create_event(&screen_ev);
// Now draw our OpenGL stuff, it does not change so we need to do it only once
GLfloat vVertices[] = {0.0f, 0.5f, 0.0f, -0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f};
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
glEnableVertexAttribArray(0);
glDrawArrays(GL_TRIANGLES, 0, 3);
int rc = eglSwapBuffers(egl_disp, egl_surf);
if (rc != EGL_TRUE) {
egl_perror("eglSwapBuffers");
}
while (1) {
do {
screen_get_event(screen_ctx, screen_ev, vis ? 0 : ~0);
screen_get_event_property_iv(screen_ev, SCREEN_PROPERTY_TYPE, &type);
if (type == SCREEN_EVENT_CLOSE) {
screen_window_t screen_win;
screen_get_event_property_pv(screen_ev, SCREEN_PROPERTY_WINDOW, (void **)&screen_win);
if (screen_win == screen_bar_win) {
screen_bar_win = NULL;
} else if (screen_win == screen_hg_win) {
screen_hg_win = NULL;
} else if (screen_win == screen_gles_win) {
screen_gles_win = NULL;
}
screen_destroy_window(screen_win);
if (!screen_bar_win || !screen_hg_win || !screen_gles_win) {
vis = 0;
}
}
if (vis) {
if (++pos[0] > dims[0] - barwidth) {
pos[0] = 0;
}
screen_set_window_property_iv(screen_bar_win, SCREEN_PROPERTY_POSITION, pos);
screen_flush_context(screen_ctx, SCREEN_WAIT_IDLE);
}
} while (type != SCREEN_EVENT_NONE);
}
screen_destroy_event(screen_ev);
screen_destroy_context(screen_ctx);
return EXIT_SUCCESS;
}
Platform* Platform::create(Game* game, void* attachToWindow)
{
FileSystem::setResourcePath("./app/native/");
Platform* platform = new Platform(game);
// Query game config
int samples = 0;
Properties* config = Game::getInstance()->getConfig()->getNamespace("window", true);
if (config)
{
samples = std::max(config->getInt("samples"), 0);
}
__gestureSet = gestures_set_alloc();
swipe_gesture_alloc(NULL, gesture_callback, __gestureSet);
pinch_gesture_alloc(NULL, gesture_callback, __gestureSet);
tap_gesture_alloc(NULL, gesture_callback, __gestureSet);
bps_initialize();
// Initialize navigator and orientation
static const int SENSOR_RATE = 25000;
sensor_set_rate(SENSOR_TYPE_AZIMUTH_PITCH_ROLL, SENSOR_RATE);
sensor_set_skip_duplicates(SENSOR_TYPE_AZIMUTH_PITCH_ROLL, true);
sensor_request_events(SENSOR_TYPE_AZIMUTH_PITCH_ROLL);
navigator_request_events(0);
navigator_rotation_lock(true);
__orientationAngle = atoi(getenv("ORIENTATION"));
int rc = 0;
int screenFormat = SCREEN_FORMAT_RGBA8888;
#ifdef __X86__
int screenUsage = SCREEN_USAGE_OPENGL_ES2;
#else
int screenUsage = SCREEN_USAGE_DISPLAY|SCREEN_USAGE_OPENGL_ES2; // Physical device copy directly into physical display
#endif
int screenSwapInterval = WINDOW_VSYNC ? 1 : 0;
int screenTransparency = SCREEN_TRANSPARENCY_NONE;
char *width_str = getenv("WIDTH");
char *height_str = getenv("HEIGHT");
// Hard-coded to (0,0).
int windowPosition[] =
{
0, 0
};
EGLint eglConfigCount;
// Hard-coded to 32-bit/OpenGL ES 2.0.
// NOTE: EGL_SAMPLE_BUFFERS and EGL_SAMPLES MUST remain at the beginning of the attribute list
// since they are expected to be at indices 0-3 in config fallback code later.
EGLint eglConfigAttrs[] =
{
EGL_SAMPLE_BUFFERS, samples > 0 ? 1 : 0,
EGL_SAMPLES, samples,
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 24,
EGL_STENCIL_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
const EGLint eglContextAttrs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
const EGLint eglSurfaceAttrs[] =
{
EGL_RENDER_BUFFER, EGL_BACK_BUFFER,
EGL_NONE
};
// Create the screen context.
rc = screen_create_context(&__screenContext, 0);
if (rc)
{
perror("screen_create_context");
goto error;
}
// Create the screen window.
rc = screen_create_window(&__screenWindow, __screenContext);
if (rc)
{
perror("screen_create_window");
goto error;
}
// Set/get any window properties.
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_FORMAT, &screenFormat);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_USAGE, &screenUsage);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
goto error;
}
if (width_str && height_str)
{
__screenWindowSize[0] = atoi(width_str);
__screenWindowSize[1] = atoi(height_str);
}
else
{
screen_display_t screen_display;
rc = screen_get_window_property_pv(__screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&screen_display);
if (rc)
{
perror("screen_get_window_property_pv(SCREEN_PROPERTY_DISPLAY)");
goto error;
}
screen_display_mode_t screen_mode;
rc = screen_get_display_property_pv(screen_display, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
if (rc)
{
perror("screen_get_display_property_pv(SCREEN_PROPERTY_MODE)");
goto error;
}
int size[2];
rc = screen_get_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc)
{
perror("screen_get_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
goto error;
}
__screenWindowSize[0] = size[0];
__screenWindowSize[1] = size[1];
if ((__orientationAngle == 0) || (__orientationAngle == 180))
{
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1])))
{
__screenWindowSize[1] = size[0];
__screenWindowSize[0] = size[1];
}
}
else if ((__orientationAngle == 90) || (__orientationAngle == 270))
{
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] < size[1])))
{
__screenWindowSize[1] = size[0];
__screenWindowSize[0] = size[1];
}
}
else
{
perror("Navigator returned an unexpected orientation angle.");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_ROTATION, &__orientationAngle);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_ROTATION)");
goto error;
}
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, __screenWindowSize);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
goto error;
}
if (windowPosition[0] != 0 || windowPosition[1] != 0)
{
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_POSITION, windowPosition);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_POSITION)");
goto error;
}
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_TRANSPARENCY, &screenTransparency);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_TRANSPARENCY)");
goto error;
}
// Double buffered.
rc = screen_create_window_buffers(__screenWindow, 2);
if (rc)
{
perror("screen_create_window_buffers");
goto error;
}
// Create screen event object.
rc = screen_create_event(&__screenEvent);
if (rc)
{
perror("screen_create_event");
goto error;
}
// Request screen events.
screen_request_events(__screenContext);
// Get the EGL display and initialize.
__eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (__eglDisplay == EGL_NO_DISPLAY)
{
perror("eglGetDisplay");
goto error;
}
if (eglInitialize(__eglDisplay, NULL, NULL) != EGL_TRUE)
{
perror("eglInitialize");
goto error;
}
if (eglChooseConfig(__eglDisplay, eglConfigAttrs, &__eglConfig, 1, &eglConfigCount) != EGL_TRUE || eglConfigCount == 0)
{
bool success = false;
while (samples)
{
// Try lowering the MSAA sample count until we find a supported config
GP_WARN("Failed to find a valid EGL configuration with EGL samples=%d. Trying samples=%d instead.", samples, samples/2);
samples /= 2;
eglConfigAttrs[1] = samples > 0 ? 1 : 0;
eglConfigAttrs[3] = samples;
if (eglChooseConfig(__eglDisplay, eglConfigAttrs, &__eglConfig, 1, &eglConfigCount) == EGL_TRUE && eglConfigCount > 0)
{
success = true;
break;
}
}
if (!success)
{
checkErrorEGL("eglChooseConfig");
goto error;
}
}
__eglContext = eglCreateContext(__eglDisplay, __eglConfig, EGL_NO_CONTEXT, eglContextAttrs);
if (__eglContext == EGL_NO_CONTEXT)
{
checkErrorEGL("eglCreateContext");
goto error;
}
__eglSurface = eglCreateWindowSurface(__eglDisplay, __eglConfig, __screenWindow, eglSurfaceAttrs);
if (__eglSurface == EGL_NO_SURFACE)
{
checkErrorEGL("eglCreateWindowSurface");
goto error;
}
if (eglMakeCurrent(__eglDisplay, __eglSurface, __eglSurface, __eglContext) != EGL_TRUE)
{
checkErrorEGL("eglMakeCurrent");
goto error;
}
// Set vsync.
eglSwapInterval(__eglDisplay, screenSwapInterval);
// Initialize OpenGL ES extensions.
__glExtensions = (const char*)glGetString(GL_EXTENSIONS);
if (strstr(__glExtensions, "GL_OES_vertex_array_object") || strstr(__glExtensions, "GL_ARB_vertex_array_object"))
{
glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)eglGetProcAddress("glBindVertexArrayOES");
glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)eglGetProcAddress("glDeleteVertexArraysOES");
glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)eglGetProcAddress("glGenVertexArraysOES");
glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)eglGetProcAddress("glIsVertexArrayOES");
}
return platform;
error:
// TODO: cleanup
return NULL;
}
Platform* Platform::create(Game* game)
{
FileSystem::setResourcePath("./app/native/");
Platform* platform = new Platform(game);
bps_initialize();
accelerometer_set_update_frequency(FREQ_40_HZ);
navigator_request_events(0);
navigator_rotation_lock(true);
// Determine initial orientation angle.
orientation_direction_t direction;
orientation_get(&direction, &__orientationAngle);
int rc = 0;
int screenFormat = SCREEN_FORMAT_RGBA8888;
int screenUsage = SCREEN_USAGE_DISPLAY|SCREEN_USAGE_OPENGL_ES2;
int screenSwapInterval = WINDOW_VSYNC ? 1 : 0;
int screenTransparency = SCREEN_TRANSPARENCY_NONE;
int angle = atoi(getenv("ORIENTATION"));
// Hard-coded to (0,0).
int windowPosition[] =
{
0, 0
};
EGLint eglConfigCount;
// Hard-coded to 32-bit/OpenGL ES 2.0.
const EGLint eglConfigAttrs[] =
{
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 24,
EGL_STENCIL_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
const EGLint eglContextAttrs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
const EGLint eglSurfaceAttrs[] =
{
EGL_RENDER_BUFFER, EGL_BACK_BUFFER,
EGL_NONE
};
// Create the screen context.
rc = screen_create_context(&__screenContext, 0);
if (rc)
{
perror("screen_create_context");
goto error;
}
// Create the screen window.
rc = screen_create_window(&__screenWindow, __screenContext);
if (rc)
{
perror("screen_create_window");
goto error;
}
// Set/get any window prooperties.
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_FORMAT, &screenFormat);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_USAGE, &screenUsage);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
goto error;
}
screen_display_t screen_display;
rc = screen_get_window_property_pv(__screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&screen_display);
if (rc)
{
perror("screen_get_window_property_pv(SCREEN_PROPERTY_DISPLAY)");
goto error;
}
screen_display_mode_t screen_mode;
rc = screen_get_display_property_pv(screen_display, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
if (rc)
{
perror("screen_get_display_property_pv(SCREEN_PROPERTY_MODE)");
goto error;
}
int size[2];
rc = screen_get_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc)
{
perror("screen_get_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
goto error;
}
__screenWindowSize[0] = size[0];
__screenWindowSize[1] = size[1];
if ((angle == 0) || (angle == 180))
{
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1])))
{
__screenWindowSize[1] = size[0];
__screenWindowSize[0] = size[1];
}
}
else if ((angle == 90) || (angle == 270))
{
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] < size[1])))
{
__screenWindowSize[1] = size[0];
__screenWindowSize[0] = size[1];
}
}
else
{
perror("Navigator returned an unexpected orientation angle.");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, __screenWindowSize);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_ROTATION, &angle);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_ROTATION)");
goto error;
}
if (windowPosition[0] != 0 || windowPosition[1] != 0)
{
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_POSITION, windowPosition);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_POSITION)");
goto error;
}
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_TRANSPARENCY, &screenTransparency);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_TRANSPARENCY)");
goto error;
}
// Double buffered.
rc = screen_create_window_buffers(__screenWindow, 2);
if (rc)
{
perror("screen_create_window_buffers");
goto error;
}
// Create screen event object.
rc = screen_create_event(&__screenEvent);
if (rc)
{
perror("screen_create_event");
goto error;
}
// Request screen events.
screen_request_events(__screenContext);
// Get the EGL display and initialize.
__eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (__eglDisplay == EGL_NO_DISPLAY)
{
perror("eglGetDisplay");
goto error;
}
if (eglInitialize(__eglDisplay, NULL, NULL) != EGL_TRUE)
{
perror("eglInitialize");
goto error;
}
if (eglChooseConfig(__eglDisplay, eglConfigAttrs, &__eglConfig, 1, &eglConfigCount) != EGL_TRUE || eglConfigCount == 0)
{
checkErrorEGL("eglChooseConfig");
goto error;
}
__eglContext = eglCreateContext(__eglDisplay, __eglConfig, EGL_NO_CONTEXT, eglContextAttrs);
if (__eglContext == EGL_NO_CONTEXT)
{
checkErrorEGL("eglCreateContext");
goto error;
}
__eglSurface = eglCreateWindowSurface(__eglDisplay, __eglConfig, __screenWindow, eglSurfaceAttrs);
if (__eglSurface == EGL_NO_SURFACE)
{
checkErrorEGL("eglCreateWindowSurface");
goto error;
}
if (eglMakeCurrent(__eglDisplay, __eglSurface, __eglSurface, __eglContext) != EGL_TRUE)
{
checkErrorEGL("eglMakeCurrent");
goto error;
}
// Set vsync.
eglSwapInterval(__eglDisplay, screenSwapInterval);
// Initialize OpenGL ES extensions.
__glExtensions = (const char*)glGetString(GL_EXTENSIONS);
if (strstr(__glExtensions, "GL_OES_vertex_array_object") || strstr(__glExtensions, "GL_ARB_vertex_array_object"))
{
// Disable VAO extension for now.
glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)eglGetProcAddress("glBindVertexArrayOES");
glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)eglGetProcAddress("glDeleteVertexArrays");
glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)eglGetProcAddress("glGenVertexArraysOES");
glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)eglGetProcAddress("glIsVertexArrayOES");
}
return platform;
error:
// TODO: cleanup
//
return NULL;
}
