static bool gfx_ctx_qnx_init(void *data)
{
/* Create a screen context that will be used to
* create an EGL surface to receive libscreen events */
RARCH_LOG("Initializing screen context...\n");
if (!screen_ctx)
{
screen_create_context(&screen_ctx, 0);
if (screen_request_events(screen_ctx) != BPS_SUCCESS)
{
RARCH_ERR("screen_request_events failed.\n");
goto screen_error;
}
if (navigator_request_events(0) != BPS_SUCCESS)
{
RARCH_ERR("navigator_request_events failed.\n");
goto screen_error;
}
if (navigator_rotation_lock(false) != BPS_SUCCESS)
{
RARCH_ERR("navigator_location_lock failed.\n");
goto screen_error;
}
}
const EGLint attribs[] = {
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_NONE
};
EGLint num_config;
EGLint egl_version_major, egl_version_minor;
int format = SCREEN_FORMAT_RGBX8888;
EGLint context_attributes[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
int usage;
usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
RARCH_LOG("Initializing context\n");
if ((g_egl_dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY)) == EGL_NO_DISPLAY)
{
RARCH_ERR("eglGetDisplay failed.\n");
goto error;
}
if (!eglInitialize(g_egl_dpy, &egl_version_major, &egl_version_minor))
{
RARCH_ERR("eglInitialize failed.\n");
goto error;
}
if (!eglBindAPI(EGL_OPENGL_ES_API))
{
RARCH_ERR("eglBindAPI failed.\n");
goto error;
}
RARCH_LOG("[BLACKBERRY QNX/EGL]: EGL version: %d.%d\n", egl_version_major, egl_version_minor);
if (!eglChooseConfig(g_egl_dpy, attribs, &egl_config, 1, &num_config))
{
RARCH_ERR("eglChooseConfig failed.\n");
goto error;
}
if ((g_egl_ctx = eglCreateContext(g_egl_dpy, egl_config, 0, context_attributes)) == EGL_NO_CONTEXT)
{
RARCH_ERR("eglCreateContext failed.\n");
goto error;
}
if(!screen_win)
{
if (screen_create_window(&screen_win, screen_ctx))
{
RARCH_ERR("screen_create_window failed:.\n");
goto error;
}
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_FORMAT, &format))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_FORMAT] failed.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_USAGE] failed.\n");
goto error;
}
if (screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&screen_disp))
{
RARCH_ERR("screen_get_window_property_pv [SCREEN_PROPERTY_DISPLAY] failed.\n");
goto error;
}
int screen_resolution[2];
if (screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_SIZE, screen_resolution))
{
RARCH_ERR("screen_get_window_property_iv [SCREEN_PROPERTY_SIZE] failed.\n");
goto error;
}
#ifndef HAVE_BB10
int angle = atoi(getenv("ORIENTATION"));
screen_display_mode_t screen_mode;
if (screen_get_display_property_pv(screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode))
{
RARCH_ERR("screen_get_display_property_pv [SCREEN_PROPERTY_MODE] failed.\n");
goto error;
}
int size[2];
if (screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size))
{
RARCH_ERR("screen_get_window_property_iv [SCREEN_PROPERTY_BUFFER_SIZE] failed.\n");
goto error;
}
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 {
RARCH_ERR("Navigator returned an unexpected orientation angle.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_BUFFER_SIZE] failed.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ROTATION, &angle))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_ROTATION] failed.\n");
goto error;
}
#endif
if (screen_create_window_buffers(screen_win, WINDOW_BUFFERS))
{
RARCH_ERR("screen_create_window_buffers failed.\n");
goto error;
}
if (!(g_egl_surf = eglCreateWindowSurface(g_egl_dpy, egl_config, screen_win, 0)))
{
RARCH_ERR("eglCreateWindowSurface failed.\n");
goto error;
}
if (!eglMakeCurrent(g_egl_dpy, g_egl_surf, g_egl_surf, g_egl_ctx))
{
RARCH_ERR("eglMakeCurrent failed.\n");
goto error;
}
return true;
error:
RARCH_ERR("EGL error: %d.\n", eglGetError());
gfx_ctx_qnx_destroy(data);
screen_error:
screen_stop_events(screen_ctx);
return false;
}
bool Game::InitDisplay()
{
/*
* Here specify the attributes of the desired configuration.
* Below, we select an EGLConfig with at least 8 bits per color
* component compatible with on-screen windows
*/
const EGLint attribs[] =
{
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_DEPTH_SIZE, 24,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, //Maybe EGL_CONFORMANT for windows and Android?
EGL_NONE
};
EGLint attrib_list[]= { EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, 0,
EGL_NONE};
EGLint w, h, format;
EGLint numConfigs;
EGLConfig config[64];
EGLSurface surface;
EGLContext context;
EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
int maj;
int min;
eglInitialize(display, &maj, &min);
Log::Debug("EGLInitialise", "EGL Major:%d Minor:%d", maj, min);
/* 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(display, attribs, &config[0], 64, &numConfigs);
for(int i = 0; i < numConfigs; i++)
{
int val[1];
eglGetConfigAttrib(display, config[i], EGL_CONFORMANT, &val[0]);
Log::Debug("EGLInitialise", "EGL_CONFORMANT: %d", val[0]);
Log::Debug("EGLInitialise", "GL2: %d", val[0] & EGL_OPENGL_ES2_BIT);
Log::Debug("EGLInitialise", "GL1: %d", val[0] & EGL_OPENGL_ES_BIT);
}
if(numConfigs == 0)
{
Log::Error("EGLInitialise", "No EGL configs were returned.");
return true;
}
/* 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(display, config[0], EGL_NATIVE_VISUAL_ID, &format);
#ifdef ANDROID
ANativeWindow_setBuffersGeometry(mDisplay.app->window, 0, 0, format); //TODO!
surface = eglCreateWindowSurface(display, config[0], mDisplay.app->window, NULL);
#endif
#ifdef _WIN32
mDisplay.WindowHandle = create_window(mDisplay.Width, mDisplay.Height);
surface = EGL_CHECK(eglCreateWindowSurface(display, config[0], (EGLNativeWindowType)mDisplay.WindowHandle, NULL));
#endif
#ifdef __QNX__
int screen_format = SCREEN_FORMAT_RGBX8888;
int usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
int screen_resolution[2];
screen_display_mode_t screen_mode;
int size[2];
int angle = std::atoi(std::getenv("ORIENTATION"));
screen_create_window(&mDisplay.qnx_screen_win, mDisplay.qnx_screen_context);
screen_set_window_property_iv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_FORMAT, &screen_format);
screen_set_window_property_iv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_USAGE, &usage);
screen_get_window_property_pv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&mDisplay.qnx_screen_disp);
screen_get_display_property_iv(mDisplay.qnx_screen_disp, SCREEN_PROPERTY_SIZE, screen_resolution);
screen_get_display_property_pv(mDisplay.qnx_screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
screen_get_window_property_iv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size);
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 {
return true;
}
screen_set_window_property_iv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size);
screen_set_window_property_iv(mDisplay.qnx_screen_win, SCREEN_PROPERTY_ROTATION, &angle);
screen_create_window_buffers(mDisplay.qnx_screen_win, 2);
surface = EGL_CHECK(eglCreateWindowSurface(display, config[0], (EGLNativeWindowType)mDisplay.qnx_screen_win, NULL));
#endif
if(surface == EGL_NO_SURFACE) {
Log::Error("EGLInitialise", "EGL Surface creation failed.");
return true;
}
const EGLint attribs2[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
context = eglCreateContext(display, config[0], NULL, attribs2);
if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) {
Log::Error("EGLInitialise", "Unable to eglMakeCurrent");
return true;
}
#ifdef __QNX__
eglSwapInterval(display, 1);
#endif
eglQuerySurface(display, surface, EGL_WIDTH, &w);
eglQuerySurface(display, surface, EGL_HEIGHT, &h);
mDisplay.Display = display;
mDisplay.Context = context;
mDisplay.Surface = surface;
mDisplay.Width = w;
mDisplay.Height = h;
mTP->camera->SetResolution(Vector2f((float)mDisplay.Width, (float)mDisplay.Height));
// Initialize GL state.
GL_CHECK(glViewport(0, 0, w, h));
GL_CHECK(glEnable(GL_DEPTH_TEST));
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GL_CHECK(glEnable(GL_BLEND));
GL_CHECK(glEnable(GL_ALPHA));
Effect::CacheTick(*mTP, EffectClearLevel::Initialise);
Texture::CacheTick(*mTP, TextureClearLevel::Initialise);
Font::CacheTick(*mTP, FontClearLevel::Initialise);
//Initialise graphics
for(std::vector<GameObject*>::iterator it = mGO.begin(); it != mGO.end(); ++it)
{
(*it)->InitialiseGraphics(*mTP);
}
return false;
}
int OpenGLView::initGL()
{
int numberDisplays;
int numberModes;
int returnCode;
EGLBoolean status;
int type;
EGLint attributes[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
EGLint attrib_list[]= { EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
EGL_NONE};
// try this first as it will fail if an HDMI display is not attached
if (m_api == GL_ES_2) {
m_egl_ctx = eglCreateContext(m_egl_disp, m_egl_conf, EGL_NO_CONTEXT, attributes);
} else {
m_egl_ctx = eglCreateContext(m_egl_disp, m_egl_conf, EGL_NO_CONTEXT, NULL);
}
if (m_egl_ctx == EGL_NO_CONTEXT) {
perror("eglCreateContext");
return EXIT_FAILURE;
}
screen_get_context_property_iv(m_screen_ctx, SCREEN_PROPERTY_DISPLAY_COUNT, &numberDisplays);
m_screen_dpy = (screen_display_t *)calloc(numberDisplays, sizeof(screen_display_t));
screen_get_context_property_pv(m_screen_ctx, SCREEN_PROPERTY_DISPLAYS, (void **)m_screen_dpy);
for (int index = 0; index < numberDisplays; index++) {
int displayID;
returnCode = screen_get_display_property_iv(m_screen_dpy[index], SCREEN_PROPERTY_ID, (int *)&displayID);
if (returnCode) {
perror("display ID");
return EXIT_FAILURE;
} else {
if (displayID == m_display) {
screen_get_display_property_iv(m_screen_dpy[index], SCREEN_PROPERTY_TYPE, &type);
if (type == SCREEN_DISPLAY_TYPE_HDMI) {
returnCode = screen_create_window(&m_screen_win, m_screen_ctx);
if (returnCode) {
perror("screen_create_window");
return EXIT_FAILURE;
}
} else {
returnCode = screen_create_window_type(&m_screen_win, m_screen_ctx, SCREEN_CHILD_WINDOW);
if (returnCode) {
perror("screen_create_window (child window)");
return EXIT_FAILURE;
}
}
if (type == SCREEN_DISPLAY_TYPE_HDMI) {
returnCode = screen_set_window_property_pv(m_screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&(m_screen_dpy[index]));
if (returnCode) {
perror("window display");
return EXIT_FAILURE;
}
}
}
}
}
qDebug() << "OpenGLView::initialize: "<< m_screen_ctx << ":" << m_egl_disp << ":" << m_egl_conf << ":" << m_egl_ctx << ":" << m_screen_win;
int format = SCREEN_FORMAT_RGBA8888;
returnCode = screen_set_window_property_iv(m_screen_win, SCREEN_PROPERTY_FORMAT, &format);
if (returnCode) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
return EXIT_FAILURE;
}
if (m_transparency > 0) {
returnCode = setWindowTransparency(m_transparency);
if (returnCode) {
perror("transparency");
return EXIT_FAILURE;
}
}
returnCode = screen_get_window_property_pv(m_screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&m_screen_disp);
if (returnCode) {
perror("screen_get_window_property_pv");
return EXIT_FAILURE;
}
int angle = atoi(getenv("ORIENTATION"));
screen_get_display_property_iv(m_screen_disp, SCREEN_PROPERTY_MODE_COUNT, &numberModes);
m_screen_modes = (screen_display_mode_t *)calloc(numberModes, sizeof(screen_display_mode_t));
returnCode = screen_get_display_property_pv(m_screen_disp, SCREEN_PROPERTY_MODE, (void**)m_screen_modes);
if (returnCode) {
perror("screen modes");
return EXIT_FAILURE;
}
int dpi = calculateDPI();
if (dpi == EXIT_FAILURE) {
fprintf(stderr, "Unable to calculate dpi\n");
return EXIT_FAILURE;
}
returnCode = setWindowPosition(m_x, m_y);
if (returnCode) {
perror("window position");
return EXIT_FAILURE;
}
returnCode = setWindowSize(m_width, m_height);
if (returnCode) {
perror("window size");
return EXIT_FAILURE;
}
returnCode = setWindowZ(m_z);
if (returnCode) {
perror("z order");
return EXIT_FAILURE;
}
returnCode = setWindowBufferSize(m_width, m_height);
if (returnCode) {
perror("buffer size");
return EXIT_FAILURE;
}
returnCode = setWindowAngle(m_angle);
if (returnCode) {
perror("angle");
return EXIT_FAILURE;
}
returnCode = screen_create_window_buffers(m_screen_win, m_nbuffers);
if (returnCode) {
perror("screen_create_window_buffers");
return EXIT_FAILURE;
}
if (m_api == GL_ES_1) {
m_usage = SCREEN_USAGE_OPENGL_ES1 | SCREEN_USAGE_ROTATION;
} else if (m_api == GL_ES_2) {
attrib_list[9] = EGL_OPENGL_ES2_BIT;
m_usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
} else if (m_api == VG) {
attrib_list[9] = EGL_OPENVG_BIT;
m_usage = SCREEN_USAGE_OPENVG | SCREEN_USAGE_ROTATION;
} else {
fprintf(stderr, "invalid api setting\n");
return EXIT_FAILURE;
}
returnCode = setWindowUsage(m_usage);
if (returnCode) {
perror("screen_set_window_property_iv(window usage)");
return EXIT_FAILURE;
}
qDebug() << "OpenGLView::initGL:eglCreateContext "<< m_egl_ctx;
m_egl_surf = eglCreateWindowSurface(m_egl_disp, m_egl_conf, m_screen_win, NULL);
if (m_egl_surf == EGL_NO_SURFACE) {
OpenGLThread::eglPrintError("eglCreateWindowSurface");
return EXIT_FAILURE;
}
getGLContext();
EGLint interval = 1;
status = eglSwapInterval(m_egl_disp, interval);
if (status != EGL_TRUE) {
OpenGLThread::eglPrintError("eglSwapInterval");
return EXIT_FAILURE;
}
status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_WIDTH, &m_surface_width);
if (status != EGL_TRUE) {
perror("query surface width");
return EXIT_FAILURE;
}
status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_HEIGHT, &m_surface_height);
if (status != EGL_TRUE) {
perror("query surface height");
return EXIT_FAILURE;
}
returnCode = joinWindowGroup(m_group);
if (returnCode) {
perror("window group");
return EXIT_FAILURE;
}
returnCode = setScreenWindowID(m_id);
if (returnCode) {
perror("window ID");
return EXIT_FAILURE;
}
qDebug() << "OpenGLView::initGL: "<< angle << ":" << numberModes << ":" << m_screen_modes[0].width << ":" << m_screen_modes[0].height << ":" << m_egl_disp << ":" << dpi;
setInitialized(true);
return EXIT_SUCCESS;
}
int
bbutil_init_egl(screen_context_t ctx, enum RENDERING_API api) {
int usage;
int format = SCREEN_FORMAT_RGBX8888;
EGLint interval = 1;
int rc, num_configs;
EGLint attributes[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
EGLint attrib_list[]= { EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
EGL_NONE};
if (api == GL_ES_1) {
usage = SCREEN_USAGE_OPENGL_ES1 | SCREEN_USAGE_ROTATION;
} else if (api == GL_ES_2) {
attrib_list[11] = EGL_OPENGL_ES2_BIT;
usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
} else if (api == VG) {
attrib_list[11] = EGL_OPENVG_BIT;
usage = SCREEN_USAGE_OPENVG | SCREEN_USAGE_ROTATION;
} else {
fprintf(stderr, "invalid api setting\n");
return EXIT_FAILURE;
}
//Simple egl initialization
screen_ctx = ctx;
egl_disp = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (egl_disp == EGL_NO_DISPLAY) {
bbutil_egl_perror("eglGetDisplay");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = eglInitialize(egl_disp, NULL, NULL);
if (rc != EGL_TRUE) {
bbutil_egl_perror("eglInitialize");
bbutil_terminate();
return EXIT_FAILURE;
}
if ((api == GL_ES_1) || (api == GL_ES_2)) {
rc = eglBindAPI(EGL_OPENGL_ES_API);
} else if (api == VG) {
rc = eglBindAPI(EGL_OPENVG_API);
}
if (rc != EGL_TRUE) {
bbutil_egl_perror("eglBindApi");
bbutil_terminate();
return EXIT_FAILURE;
}
if(!eglChooseConfig(egl_disp, attrib_list, &egl_conf, 1, &num_configs)) {
bbutil_terminate();
return EXIT_FAILURE;
}
if (api == GL_ES_2) {
egl_ctx = eglCreateContext(egl_disp, egl_conf, EGL_NO_CONTEXT, attributes);
} else {
egl_ctx = eglCreateContext(egl_disp, egl_conf, EGL_NO_CONTEXT, NULL);
}
if (egl_ctx == EGL_NO_CONTEXT) {
bbutil_egl_perror("eglCreateContext");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_create_window(&screen_win, screen_ctx);
if (rc) {
perror("screen_create_window");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_FORMAT, &format);
if (rc) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage);
if (rc) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&screen_disp);
if (rc) {
perror("screen_get_window_property_pv");
bbutil_terminate();
return EXIT_FAILURE;
}
int angle = atoi(getenv("ORIENTATION"));
screen_display_mode_t screen_mode;
rc = screen_get_display_property_pv(screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
if (rc) {
perror("screen_get_display_property_pv");
bbutil_terminate();
return EXIT_FAILURE;
}
int size[2];
rc = screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc) {
perror("screen_get_window_property_iv");
bbutil_terminate();
return EXIT_FAILURE;
}
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 {
fprintf(stderr, "Navigator returned an unexpected orientation angle.\n");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size);
if (rc) {
perror("screen_set_window_property_iv");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ROTATION, &angle);
if (rc) {
perror("screen_set_window_property_iv");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = screen_create_window_buffers(screen_win, nbuffers);
if (rc) {
perror("screen_create_window_buffers");
bbutil_terminate();
return EXIT_FAILURE;
}
egl_surf = eglCreateWindowSurface(egl_disp, egl_conf, screen_win, NULL);
if (egl_surf == EGL_NO_SURFACE) {
bbutil_egl_perror("eglCreateWindowSurface");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = eglMakeCurrent(egl_disp, egl_surf, egl_surf, egl_ctx);
if (rc != EGL_TRUE) {
bbutil_egl_perror("eglMakeCurrent");
bbutil_terminate();
return EXIT_FAILURE;
}
rc = eglSwapInterval(egl_disp, interval);
if (rc != EGL_TRUE) {
bbutil_egl_perror("eglSwapInterval");
bbutil_terminate();
return EXIT_FAILURE;
}
initialized = 1;
return EXIT_SUCCESS;
}
// Video
int init_GLES2(screen_context_t ctx) {
int usage = SCREEN_USAGE_ROTATION | SCREEN_USAGE_OPENGL_ES2;
int format = SCREEN_FORMAT_RGBX8888;
int num_configs;
EGLint attrib_list[]= {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_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 attributes[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
const EGLint egl_surfaceAttr[] = { EGL_RENDER_BUFFER, EGL_BACK_BUFFER, EGL_NONE };
screen_ctx = ctx;
screen_create_window(&screen_win, screen_ctx);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_FORMAT, &format);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage);
screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&screen_disp);
// This must be landscape.
int screen_resolution[2];
screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_SIZE, screen_resolution);
int angle = atoi(getenv("ORIENTATION"));
pixel_xres = screen_resolution[0]; pixel_yres = screen_resolution[1];
screen_display_mode_t screen_mode;
screen_get_display_property_pv(screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
int size[2];
screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size);
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];
pixel_yres = screen_resolution[0];
pixel_xres = screen_resolution[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];
pixel_yres = screen_resolution[0];
pixel_xres = screen_resolution[1];
}
}
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ROTATION, &angle);
screen_create_window_buffers(screen_win, 2); // Double buffered
egl_disp = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(egl_disp, NULL, NULL);
eglChooseConfig(egl_disp, attrib_list, &egl_conf, 1, &num_configs);
egl_ctx = eglCreateContext(egl_disp, egl_conf, EGL_NO_CONTEXT, attributes);
egl_surf = eglCreateWindowSurface(egl_disp, egl_conf, screen_win, egl_surfaceAttr);
eglMakeCurrent(egl_disp, egl_surf, egl_surf, egl_ctx);
eglSwapInterval(egl_disp, 1);
return 0;
}
bool CIrrDeviceBB10::createWindow()
{
if ( Close )
return false;
int rc = screen_create_window(&bspScreenWindow, bspScreenCtx);
if(rc)
{
os::Printer::log("Screen create window failed!");
return false;
}
if(video::EDT_OGLES1 != CreationParams.DriverType && video::EDT_OGLES2 !=CreationParams.DriverType)
return false;
bspformat = SCREEN_FORMAT_RGBX8888;
if(CreationParams.Bits==16)
bspformat = SCREEN_FORMAT_RGBX4444;
bspUsage = SCREEN_USAGE_OPENGL_ES1 | SCREEN_USAGE_ROTATION;
if(video::EDT_OGLES2 ==CreationParams.DriverType)
bspUsage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
//window properties
rc = screen_set_window_property_iv(bspScreenWindow, SCREEN_PROPERTY_FORMAT, &bspformat);
rc = screen_set_window_property_iv(bspScreenWindow, SCREEN_PROPERTY_USAGE, &bspUsage);
screen_display_t screenDisplay;
rc = screen_get_window_property_pv(bspScreenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&screenDisplay);
int screenResolution[2];
rc = screen_get_display_property_iv(screenDisplay, SCREEN_PROPERTY_SIZE, screenResolution);
int angle = atoi(getenv("ORIENTATION"));
screen_display_mode_t screenDisplayMode;
rc = screen_get_display_property_pv(screenDisplay, SCREEN_PROPERTY_MODE, (void**)&screenDisplayMode);
int bufferSize[2];
rc = screen_get_window_property_iv(bspScreenWindow, SCREEN_PROPERTY_BUFFER_SIZE, bufferSize);
int newBufferSize[2] = {bufferSize[0], bufferSize[1]};
if ((angle == 0) || (angle == 180))
{
if (((screenDisplayMode.width > screenDisplayMode.height) && (bufferSize[0] < bufferSize[1]))
|| ((screenDisplayMode.width < screenDisplayMode.height) && (bufferSize[0] > bufferSize[1])))
{
newBufferSize[1] = bufferSize[0];
newBufferSize[0] = bufferSize[1];
}
}
else if ((angle == 90) || (angle == 270))
{
if (((screenDisplayMode.width > screenDisplayMode.height) && (bufferSize[0] > bufferSize[1]))
|| ((screenDisplayMode.width < screenDisplayMode.height && bufferSize[0] < bufferSize[1])))
{
newBufferSize[1] = bufferSize[0];
newBufferSize[0] = bufferSize[1];
}
}
else
{
os::Printer::log("Navigator returned an unexpected orientation angle.\n");
return false;
}
rc = screen_set_window_property_iv(bspScreenWindow, SCREEN_PROPERTY_BUFFER_SIZE, newBufferSize);
rc = screen_set_window_property_iv(bspScreenWindow, SCREEN_PROPERTY_ROTATION, &angle);
rc = screen_create_window_buffers(bspScreenWindow, 2);
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;
}
int
setup_screen()
{
if (screen_create_context(&screen_ctx, SCREEN_APPLICATION_CONTEXT) != 0) {
return EXIT_FAILURE;
}
//Signal BPS library that navigator orientation is to be locked
if (BPS_SUCCESS != navigator_rotation_lock(true)) {
screen_destroy_context(screen_ctx);
return EXIT_FAILURE;
}
if (screen_create_window(&screen_win, screen_ctx) != 0) {
screen_destroy_context(screen_ctx);
return EXIT_FAILURE;
}
if (screen_create_window_group(screen_win, get_window_group_id()) != 0) goto fail;
int usage = SCREEN_USAGE_NATIVE;
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage) != 0) goto fail;
int size[2];
if (screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size) != 0) goto fail;
screen_display_t screen_disp;
screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&screen_disp);
screen_display_mode_t screen_mode;
if (screen_get_display_property_pv(screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode) != 0) goto fail;
int buffer_size[2] = {size[0], size[1]};
int angle = atoi(getenv("ORIENTATION"));
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 {
goto fail;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size) != 0) goto fail;
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ROTATION, &angle) != 0) goto fail;
if (screen_create_window_buffers(screen_win, 1) != 0) goto fail;
screen_buffer_t buff;
if (screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_RENDER_BUFFERS, (void*)&buff) != 0) goto fail;
int attribs[1] = {SCREEN_BLIT_END};
if (screen_fill(screen_ctx, buff, attribs) != 0) goto fail;
int dirty_rects[4] = {0, 0, buffer_size[0], buffer_size[1]};
if (screen_post_window(screen_win, buff, 1, (const int*)dirty_rects, 0) != 0) goto fail;
return EXIT_SUCCESS;
fail:
perror(NULL);
cleanup_screen();
return EXIT_FAILURE;
}
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;
}
int NativeWindow::initialize(bool _createFullWindow)
{
int returnCode;
int numberModes;
screen_display_mode_t* screenModes;
int type;
if (_createFullWindow) {
returnCode = screen_create_window(&_screenWindow, _screenContext);
qDebug() << "NativeWindow::initialize: _screenWindow (full window): " << ":" << _screenWindow << ":" << _screenContext << ":" << returnCode;
if (returnCode) {
perror("screen_create_window");
return EXIT_FAILURE;
}
} else {
returnCode = screen_create_window_type(&_screenWindow, _screenContext, SCREEN_CHILD_WINDOW);
qDebug() << "NativeWindow::initialize: _screenWindow (child window): " << _screenWindow << ":" << returnCode;
if (returnCode) {
perror("screen_create_window (child window)");
return EXIT_FAILURE;
}
}
_displaysMutex.lock();
if (_screenDisplays) {
free (_screenDisplays);
}
// try this first as it will fail if an HDMI display is not attached
screen_get_context_property_iv(_screenContext, SCREEN_PROPERTY_DISPLAY_COUNT, &_numberDisplays);
_screenDisplays = (screen_display_t *)calloc(_numberDisplays, sizeof(screen_display_t));
screen_get_context_property_pv(_screenContext, SCREEN_PROPERTY_DISPLAYS, (void **)_screenDisplays);
for (int index = 0; index < _numberDisplays; index++) {
int displayID;
returnCode = screen_get_display_property_iv(_screenDisplays[index], SCREEN_PROPERTY_ID, (int *)&displayID);
qDebug() << "NativeWindow::initialize: display: " << ":" << index << ":" << displayID << ":" << _display << ":" << _screenDisplays[index];
if (returnCode) {
perror("display ID");
return EXIT_FAILURE;
} else {
if (displayID == _display) {
screen_get_display_property_iv(_screenDisplays[index], SCREEN_PROPERTY_TYPE, &type);
if (type == SCREEN_DISPLAY_TYPE_HDMI) {
returnCode = screen_set_window_property_pv(_screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&(_screenDisplays[index]));
if (returnCode) {
perror("window display");
return EXIT_FAILURE;
}
}
}
}
}
_displaysMutex.unlock();
qDebug() << "NativeWindow::initialize: "<< _screenContext << ":" << _screenWindow;
returnCode = setWindowFormat(_format);
if (returnCode) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
return EXIT_FAILURE;
}
returnCode = setWindowTransparency(_transparency);
if (returnCode) {
perror("transparency");
return EXIT_FAILURE;
}
returnCode = screen_get_window_property_pv(_screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&_screenDisplay);
if (returnCode) {
perror("screenDisplay");
return EXIT_FAILURE;
}
int angle = atoi(getenv("ORIENTATION"));
screen_get_display_property_iv(_screenDisplay, SCREEN_PROPERTY_MODE_COUNT, &numberModes);
screenModes = (screen_display_mode_t *)calloc(numberModes, sizeof(screen_display_mode_t));
returnCode = screen_get_display_property_pv(_screenDisplay, SCREEN_PROPERTY_MODE, (void**)screenModes);
if (returnCode) {
perror("screen modes");
return EXIT_FAILURE;
}
int dpi = calculateDPI();
if (dpi == EXIT_FAILURE) {
fprintf(stderr, "Unable to calculate dpi\n");
return EXIT_FAILURE;
}
returnCode = setWindowPosition(_x, _y);
if (returnCode) {
perror("window position");
return EXIT_FAILURE;
}
returnCode = setWindowSize(_width, _height);
if (returnCode) {
perror("window size");
return EXIT_FAILURE;
}
returnCode = setWindowZ(_z);
if (returnCode) {
perror("z order");
return EXIT_FAILURE;
}
if (_sourceWidth > 0) {
returnCode = setWindowSourcePosition(_sourceX, _sourceY);
if (returnCode) {
perror("source size");
return EXIT_FAILURE;
}
returnCode = setWindowSourceSize(_sourceWidth, _sourceHeight);
if (returnCode) {
perror("source size");
return EXIT_FAILURE;
}
}
if (_bufferWidth > 0) {
returnCode = setWindowBufferSize(_bufferWidth, _bufferHeight);
if (returnCode) {
perror("buffer size");
return EXIT_FAILURE;
}
}
returnCode = setWindowAngle(_angle);
if (returnCode) {
perror("angle");
return EXIT_FAILURE;
}
returnCode = screen_create_window_buffers(_screenWindow, _nbuffers);
if (returnCode) {
perror("screen_create_window_buffers");
return EXIT_FAILURE;
}
_usage = Graphics::getNativeWindowUsage();
// enable this in case we need any native API access to this window
_usage |= SCREEN_USAGE_NATIVE;
returnCode = setWindowUsage(_usage);
if (returnCode) {
perror("screen_set_window_property_iv(window usage)");
return EXIT_FAILURE;
}
returnCode = joinWindowGroup(_group);
if (returnCode) {
perror("window group");
return EXIT_FAILURE;
}
returnCode = setScreenWindowID(_id);
if (returnCode) {
perror("window ID");
return EXIT_FAILURE;
}
qDebug() << "NativeWindow::initialize: "<< angle << ":" << numberModes << ":" << screenModes[0].width << ":" << screenModes[0].height << ":" << dpi;
if (screenModes != NULL) {
free(screenModes);
}
return EXIT_SUCCESS;
}
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;
}
static void *gfx_ctx_qnx_init(video_frame_info_t *video_info, void *video_driver)
{
EGLint n;
EGLint major, minor;
EGLint context_attributes[] = {
#ifdef HAVE_OPENGLES2
EGL_CONTEXT_CLIENT_VERSION, 2,
#elif HAVE_OPENGLES3
EGL_CONTEXT_CLIENT_VERSION, 3,
#endif
EGL_NONE
};
const EGLint attribs[] = {
#ifdef HAVE_OPENGLES2
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
#elif HAVE_OPENGLES3
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR,
#endif
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_NONE
};
qnx_ctx_data_t *qnx = (qnx_ctx_data_t*)calloc(1, sizeof(*qnx));
if (!qnx)
goto screen_error;
/* Create a screen context that will be used to
* create an EGL surface to receive libscreen events */
RARCH_LOG("Initializing screen context...\n");
if (!screen_ctx)
{
screen_create_context(&screen_ctx, 0);
if (screen_request_events(screen_ctx) != BPS_SUCCESS)
{
RARCH_ERR("screen_request_events failed.\n");
goto screen_error;
}
if (navigator_request_events(0) != BPS_SUCCESS)
{
RARCH_ERR("navigator_request_events failed.\n");
goto screen_error;
}
if (navigator_rotation_lock(false) != BPS_SUCCESS)
{
RARCH_ERR("navigator_location_lock failed.\n");
goto screen_error;
}
}
#ifdef HAVE_EGL
if (!egl_init_context(&qnx->egl, EGL_NONE, EGL_DEFAULT_DISPLAY, &major, &minor,
&n, attribs))
{
egl_report_error();
goto error;
}
if (!egl_create_context(&qnx->egl, context_attributes))
{
egl_report_error();
goto error;
}
#endif
if(!screen_win)
{
if (screen_create_window(&screen_win, screen_ctx))
{
RARCH_ERR("screen_create_window failed:.\n");
goto error;
}
}
int format = SCREEN_FORMAT_RGBX8888;
if (screen_set_window_property_iv(screen_win,
SCREEN_PROPERTY_FORMAT, &format))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_FORMAT] failed.\n");
goto error;
}
int usage;
#ifdef HAVE_OPENGLES2
usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
#elif HAVE_OPENGLES3
usage = SCREEN_USAGE_OPENGL_ES3 | SCREEN_USAGE_ROTATION;
#endif
if (screen_set_window_property_iv(screen_win,
SCREEN_PROPERTY_USAGE, &usage))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_USAGE] failed.\n");
goto error;
}
if (screen_get_window_property_pv(screen_win,
SCREEN_PROPERTY_DISPLAY, (void **)&qnx->screen_disp))
{
RARCH_ERR("screen_get_window_property_pv [SCREEN_PROPERTY_DISPLAY] failed.\n");
goto error;
}
int screen_resolution[2];
if (screen_get_display_property_iv(qnx->screen_disp,
SCREEN_PROPERTY_SIZE, screen_resolution))
{
RARCH_ERR("screen_get_window_property_iv [SCREEN_PROPERTY_SIZE] failed.\n");
goto error;
}
#ifndef HAVE_BB10
int angle, size[2];
angle = atoi(getenv("ORIENTATION"));
screen_display_mode_t screen_mode;
if (screen_get_display_property_pv(qnx->screen_disp,
SCREEN_PROPERTY_MODE, (void**)&screen_mode))
{
RARCH_ERR("screen_get_display_property_pv [SCREEN_PROPERTY_MODE] failed.\n");
goto error;
}
if (screen_get_window_property_iv(screen_win,
SCREEN_PROPERTY_BUFFER_SIZE, size))
{
RARCH_ERR("screen_get_window_property_iv [SCREEN_PROPERTY_BUFFER_SIZE] failed.\n");
goto error;
}
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
{
RARCH_ERR("Navigator returned an unexpected orientation angle.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win,
SCREEN_PROPERTY_BUFFER_SIZE, buffer_size))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_BUFFER_SIZE] failed.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win,
SCREEN_PROPERTY_ROTATION, &angle))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_ROTATION] failed.\n");
goto error;
}
#endif
if (screen_create_window_buffers(screen_win, WINDOW_BUFFERS))
{
RARCH_ERR("screen_create_window_buffers failed.\n");
goto error;
}
if (!egl_create_surface(&qnx->egl, screen_win))
goto error;
return qnx;
error:
RARCH_ERR("EGL error: %d.\n", eglGetError());
gfx_ctx_qnx_destroy(video_driver);
screen_error:
screen_stop_events(screen_ctx);
return NULL;
}
