/**
* Initialize EGL by specified params
* Create a Window Surface for on-screen render
*/
int initEGL(SdkEnv *env)
{
LOG_ENTRY;
VALIDATE_NOT_NULL(env);
VALIDATE_NOT_NULL(env->egl.window);
env->egl.display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (EGL_NO_DISPLAY == env->egl.display || EGL_SUCCESS != eglGetError()) {
LogE("Failed eglGetDisplay\n");
return -1;
}
EGLint major, minor;
if (!eglInitialize(env->egl.display, &major, &minor) || EGL_SUCCESS != eglGetError()) {
LogE("Failed eglInitialize\n");
return -1;
}
Log("EGL %d.%d\n", major, minor);
EGLConfig configs[2];
EGLint numConfigs;
if (eglGetConfigs(env->egl.display, configs, 2, &numConfigs) == EGL_FALSE || EGL_SUCCESS != eglGetError()) {
LogE("Failed eglGetConfigs\n");
return -1;
}
EGLint cfg_attrs[] = {
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_NONE
};
if (!eglChooseConfig(env->egl.display, cfg_attrs, configs, 2, &numConfigs) || numConfigs < 1) {
LogE("Failed eglChooseConfig\n");
return -1;
}
EGLint surface_attrs[] = {
EGL_NONE
};
env->egl.surface = eglCreateWindowSurface(env->egl.display, configs[0], env->egl.window, surface_attrs);
if (EGL_NO_SURFACE == env->egl.surface) {
LogE("Failed create Window Surface, error code:%x\n", eglGetError());
return -1;
}
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
LogE("Failed eglBindAPI\n");
return -1;
}
EGLint context_attrs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
env->egl.context = eglCreateContext(env->egl.display, configs[0], EGL_NO_CONTEXT, context_attrs);
if (EGL_NO_CONTEXT == env->egl.context) {
LogE("Failed create context, error code:%x\n", eglGetError() );
return -1;
}
if (!eglMakeCurrent(env->egl.display, env->egl.surface, env->egl.surface, env->egl.context)) {
LogE("Failed eglMakeCurrent, error code:%x\n", eglGetError() );
return -1;
}
eglQuerySurface(env->egl.display, env->egl.surface, EGL_WIDTH, &env->egl.width);
eglQuerySurface(env->egl.display, env->egl.surface, EGL_HEIGHT, &env->egl.height);
Log("EGL Window Surface %d x %d\n", env->egl.width, env->egl.height);
env->type = ON_SCREEN_RENDER;
LOG_EXIT;
return 0;
}
static int _egl_init (s52engine *engine)
{
g_print("s52egl:_egl_init(): starting ..\n");
if ((NULL!=engine->eglDisplay) && (EGL_NO_DISPLAY!=engine->eglDisplay)) {
g_print("_egl_init(): EGL is already up .. skipped!\n");
return FALSE;
}
// EGL Error code -
// #define EGL_SUCCESS 0x3000
// #define EGL_NOT_INITIALIZED 0x3001
// #define EGL_BAD_ACCESS 0x3002
// #define EGL_BAD_ALLOC 0x3003
// #define EGL_BAD_ATTRIBUTE 0x3004
// #define EGL_BAD_CONFIG 0x3005
// #define EGL_BAD_CONTEXT 0x3006
// #define EGL_BAD_CURRENT_SURFACE 0x3007
// #define EGL_BAD_DISPLAY 0x3008
// #define EGL_BAD_MATCH 0x3009
// #define EGL_BAD_NATIVE_PIXMAP 0x300A
// #define EGL_BAD_NATIVE_WINDOW 0x300B
// #define EGL_BAD_PARAMETER 0x300C
// #define EGL_BAD_SURFACE 0x300D
// #define EGL_CONTEXT_LOST 0x300E
EGLNativeWindowType eglWindow = 0;
EGLDisplay eglDisplay = EGL_NO_DISPLAY;
EGLSurface eglSurface = EGL_NO_SURFACE;
EGLContext eglContext = EGL_NO_CONTEXT;
EGLBoolean ret = eglBindAPI(EGL_OPENGL_ES_API);
if (EGL_TRUE != ret)
g_print("eglBindAPI() failed. [0x%x]\n", eglGetError());
eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (EGL_NO_DISPLAY == eglDisplay)
g_print("eglGetDisplay() failed. [0x%x]\n", eglGetError());
EGLint major = 2;
EGLint minor = 0;
if (EGL_FALSE == eglInitialize(eglDisplay, &major, &minor) || EGL_SUCCESS != eglGetError())
g_print("eglInitialize() failed. [0x%x]\n", eglGetError());
g_print("EGL Version :%s\n", eglQueryString(eglDisplay, EGL_VERSION));
g_print("EGL Vendor :%s\n", eglQueryString(eglDisplay, EGL_VENDOR));
g_print("EGL Extensions:%s\n", eglQueryString(eglDisplay, EGL_EXTENSIONS));
// 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
EGLint eglNumConfigs = 0;
EGLConfig eglConfig;
eglGetConfigs(eglDisplay, NULL, 0, &eglNumConfigs);
g_print("eglNumConfigs = %i\n", eglNumConfigs);
/*
int i = 0;
for (i = 0; i<eglNumConfigs; ++i) {
EGLint samples = 0;
//if (EGL_FALSE == eglGetConfigAttrib(eglDisplay, eglConfig[i], EGL_SAMPLES, &samples))
// printf("eglGetConfigAttrib in loop for an EGL_SAMPLES fail at i = %i\n", i);
if (EGL_FALSE == eglGetConfigAttrib(eglDisplay, eglConfig[i], EGL_SAMPLE_BUFFERS, &samples))
printf("eglGetConfigAttrib in loop for an EGL_SAMPLE_BUFFERS fail at i = %i\n", i);
if (samples > 0)
printf("sample found: %i\n", samples);
}
eglGetConfigs(eglDisplay, configs, num_config[0], num_config))
*/
// 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 eglConfigList[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_NONE
};
if (EGL_FALSE == eglChooseConfig(eglDisplay, eglConfigList, &eglConfig, 1, &eglNumConfigs))
g_print("eglChooseConfig() failed. [0x%x]\n", eglGetError());
if (0 == eglNumConfigs)
g_print("eglChooseConfig() eglNumConfigs no matching config [0x%x]\n", eglGetError());
eglWindow = (EGLNativeWindowType) gtk_widget_get_window(engine->window);
if (FALSE == eglWindow) {
g_print("ERROR: EGLNativeWindowType is NULL (can't draw)\n");
g_assert(0);
}
g_print("DEBUG: eglDisplay =0X%X\n", (guint)eglDisplay);
g_print("DEBUG: eglConfig =0X%X\n", (guint)eglConfig);
g_print("DEBUG: eglWindowXID=0X%X\n", (guint)GDK_WINDOW_XID(eglWindow));
eglSurface = eglCreateWindowSurface(eglDisplay, eglConfig, GDK_WINDOW_XID(gtk_widget_get_window(engine->window)), NULL);
if (EGL_NO_SURFACE == eglSurface || EGL_SUCCESS != eglGetError())
g_print("eglCreateWindowSurface() failed. EGL_NO_SURFACE [0x%x]\n", eglGetError());
// Then we can create the context and set it current:
EGLint eglContextList[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
eglContext = eglCreateContext(eglDisplay, eglConfig, EGL_NO_CONTEXT, eglContextList);
if (EGL_NO_CONTEXT == eglContext || EGL_SUCCESS != eglGetError())
g_print("eglCreateContext() failed. [0x%x]\n", eglGetError());
if (EGL_FALSE == eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext))
g_print("Unable to eglMakeCurrent()\n");
engine->eglDisplay = eglDisplay;
engine->eglContext = eglContext;
engine->eglSurface = eglSurface;
engine->eglWindow = eglWindow;
g_print("s52egl:_egl_init(): end ..\n");
return 1;
}
// Create the OpenGL or OpenGL ES context
//
GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
EGLint attribs[40];
EGLConfig config;
EGLContext share = NULL;
if (!_glfw.egl.display)
{
_glfwInputError(GLFW_API_UNAVAILABLE, "EGL: API not available");
return GLFW_FALSE;
}
if (ctxconfig->share)
share = ctxconfig->share->context.egl.handle;
if (!chooseEGLConfig(ctxconfig, fbconfig, &config))
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
"EGL: Failed to find a suitable EGLConfig");
return GLFW_FALSE;
}
if (ctxconfig->client == GLFW_OPENGL_ES_API)
{
if (!eglBindAPI(EGL_OPENGL_ES_API))
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to bind OpenGL ES: %s",
getEGLErrorString(eglGetError()));
return GLFW_FALSE;
}
}
else
{
if (!eglBindAPI(EGL_OPENGL_API))
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to bind OpenGL: %s",
getEGLErrorString(eglGetError()));
return GLFW_FALSE;
}
}
if (_glfw.egl.KHR_create_context)
{
int index = 0, mask = 0, flags = 0;
if (ctxconfig->client == GLFW_OPENGL_API)
{
if (ctxconfig->forward)
flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE)
mask |= EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE)
mask |= EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
if (_glfw.egl.KHR_create_context_no_error)
{
if (ctxconfig->noerror)
flags |= EGL_CONTEXT_OPENGL_NO_ERROR_KHR;
}
}
if (ctxconfig->debug)
flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
if (ctxconfig->robustness)
{
if (ctxconfig->robustness == GLFW_NO_RESET_NOTIFICATION)
{
setEGLattrib(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR,
EGL_NO_RESET_NOTIFICATION_KHR);
}
else if (ctxconfig->robustness == GLFW_LOSE_CONTEXT_ON_RESET)
{
setEGLattrib(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR,
EGL_LOSE_CONTEXT_ON_RESET_KHR);
}
flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
}
if (ctxconfig->major != 1 || ctxconfig->minor != 0)
{
setEGLattrib(EGL_CONTEXT_MAJOR_VERSION_KHR, ctxconfig->major);
setEGLattrib(EGL_CONTEXT_MINOR_VERSION_KHR, ctxconfig->minor);
}
if (mask)
setEGLattrib(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, mask);
if (flags)
setEGLattrib(EGL_CONTEXT_FLAGS_KHR, flags);
setEGLattrib(EGL_NONE, EGL_NONE);
}
else
{
int index = 0;
if (ctxconfig->client == GLFW_OPENGL_ES_API)
setEGLattrib(EGL_CONTEXT_CLIENT_VERSION, ctxconfig->major);
setEGLattrib(EGL_NONE, EGL_NONE);
}
// Context release behaviors (GL_KHR_context_flush_control) are not yet
// supported on EGL but are not a hard constraint, so ignore and continue
window->context.egl.handle = eglCreateContext(_glfw.egl.display,
config, share, attribs);
if (window->context.egl.handle == EGL_NO_CONTEXT)
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"EGL: Failed to create context: %s",
getEGLErrorString(eglGetError()));
return GLFW_FALSE;
}
// Set up attributes for surface creation
{
int index = 0;
if (fbconfig->sRGB)
{
if (_glfw.egl.KHR_gl_colorspace)
{
setEGLattrib(EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR);
}
}
setEGLattrib(EGL_NONE, EGL_NONE);
}
window->context.egl.surface =
eglCreateWindowSurface(_glfw.egl.display,
config,
_GLFW_EGL_NATIVE_WINDOW,
attribs);
if (window->context.egl.surface == EGL_NO_SURFACE)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to create window surface: %s",
getEGLErrorString(eglGetError()));
return GLFW_FALSE;
}
window->context.egl.config = config;
// Load the appropriate client library
{
int i;
const char** sonames;
const char* es1sonames[] =
{
#if defined(_GLFW_WIN32)
"GLESv1_CM.dll",
"libGLES_CM.dll",
#elif defined(_GLFW_COCOA)
"libGLESv1_CM.dylib",
#else
"libGLESv1_CM.so.1",
"libGLES_CM.so.1",
#endif
NULL
};
const char* es2sonames[] =
{
#if defined(_GLFW_WIN32)
"GLESv2.dll",
"libGLESv2.dll",
#elif defined(_GLFW_COCOA)
"libGLESv2.dylib",
#else
"libGLESv2.so.2",
#endif
NULL
};
const char* glsonames[] =
{
#if defined(_GLFW_WIN32)
#elif defined(_GLFW_COCOA)
#else
"libGL.so.1",
#endif
NULL
};
if (ctxconfig->client == GLFW_OPENGL_ES_API)
{
if (ctxconfig->major == 1)
sonames = es1sonames;
else
sonames = es2sonames;
}
else
sonames = glsonames;
for (i = 0; sonames[i]; i++)
{
// HACK: Match presence of lib prefix to increase chance of finding
// a matching pair in the jungle that is Win32 EGL/GLES
if (_glfw.egl.prefix != (strncmp(sonames[i], "lib", 3) == 0))
continue;
window->context.egl.client = _glfw_dlopen(sonames[i]);
if (window->context.egl.client)
break;
}
if (!window->context.egl.client)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to load client library");
return GLFW_FALSE;
}
}
window->context.makeCurrent = makeContextCurrentEGL;
window->context.swapBuffers = swapBuffersEGL;
window->context.swapInterval = swapIntervalEGL;
window->context.extensionSupported = extensionSupportedEGL;
window->context.getProcAddress = getProcAddressEGL;
window->context.destroy = destroyContextEGL;
return GLFW_TRUE;
}
xdl_int XdevLWindowWayland::initializeEGL() {
static const EGLint context_attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
const char *extensions;
EGLint config_attribs[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
EGL_ALPHA_SIZE, 1,
EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
EGL_NONE
};
EGLint major, minor, n, count, i, size;
m_egl.m_eglDisplay = eglGetDisplay((EGLNativeDisplayType)display);
if(m_egl.m_eglDisplay == EGL_NO_DISPLAY) {
XDEVL_MODULE_ERROR("Can't create egl display\n");
return ERR_ERROR;
} else {
XDEVL_MODULE_SUCCESS("Created egl display\n");
}
EGLBoolean ret = eglInitialize(m_egl.m_eglDisplay, &major, &minor);
if(ret != EGL_TRUE) {
XDEVL_MODULE_ERROR("Can't initialize egl display\n");
return ERR_ERROR;
}
ret = eglBindAPI(EGL_OPENGL_ES_API);
if(ret != EGL_TRUE) {
XDEVL_MODULE_ERROR("Can't bind egl API to EGL_OPENGL_ES_API\n");
return ERR_ERROR;
}
if(!eglGetConfigs(m_egl.m_eglDisplay, nullptr, 0, &count) || count < 1) {
return ERR_ERROR;
}
EGLConfig* configs = new EGLConfig[count];
ret = eglChooseConfig(m_egl.m_eglDisplay, config_attribs, configs, count, &n);
if(ret != EGL_TRUE) {
return ERR_ERROR;
}
// TODO This is at the moment for only test purpose. As you can see only the first
// config is used.
for(i = 0; i < n; i++) {
eglGetConfigAttrib(m_egl.m_eglDisplay, configs[i], EGL_BUFFER_SIZE, &size);
printf("Buffer size for config %d is %d\n", i, size);
// For now just use the first one.
m_egl.m_eglConfig = configs[0];
}
delete [] configs;
// If we do not found any configs stop here.
if(m_egl.m_eglConfig == nullptr) {
return ERR_ERROR;
}
m_egl.m_eglContext = eglCreateContext(m_egl.m_eglDisplay, m_egl.m_eglConfig, EGL_NO_CONTEXT, context_attribs);
if(m_egl.m_eglContext == nullptr) {
return ERR_ERROR;
}
}
/**
** Initialize the video part for SDL.
*/
void InitVideoSdl()
{
Uint32 flags = 0;
if (SDL_WasInit(SDL_INIT_VIDEO) == 0) {
#ifndef USE_WIN32
// Fix tablet input in full-screen mode
SDL_putenv(strdup("SDL_MOUSE_RELATIVE=0"));
#endif
int res = SDL_Init(
#ifdef DEBUG
SDL_INIT_NOPARACHUTE |
#endif
SDL_INIT_AUDIO | SDL_INIT_VIDEO |
SDL_INIT_TIMER);
if (res < 0) {
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
exit(1);
}
// Clean up on exit
atexit(SDL_Quit);
// If debug is enabled, Stratagus disable SDL Parachute.
// So we need gracefully handle segfaults and aborts.
#if defined(DEBUG) && !defined(USE_WIN32)
signal(SIGSEGV, CleanExit);
signal(SIGABRT, CleanExit);
#endif
// Set WindowManager Title
if (!FullGameName.empty()) {
SDL_WM_SetCaption(FullGameName.c_str(), FullGameName.c_str());
} else if (!Parameters::Instance.applicationName.empty()) {
SDL_WM_SetCaption(Parameters::Instance.applicationName.c_str(), Parameters::Instance.applicationName.c_str());
} else {
SDL_WM_SetCaption("Stratagus", "Stratagus");
}
#if ! defined(USE_WIN32)
#if defined(USE_OPENGL) || defined(USE_GLES)
// Make sure, that we not create OpenGL textures (and do not call OpenGL functions), when creating icon surface
bool UseOpenGL_orig = UseOpenGL;
UseOpenGL = false;
#endif
SDL_Surface *icon = NULL;
CGraphic *g = NULL;
struct stat st;
std::string FullGameNameL = FullGameName;
for (size_t i = 0; i < FullGameNameL.size(); ++i) {
FullGameNameL[i] = tolower(FullGameNameL[i]);
}
std::string ApplicationName = Parameters::Instance.applicationName;
std::string ApplicationNameL = ApplicationName;
for (size_t i = 0; i < ApplicationNameL.size(); ++i) {
ApplicationNameL[i] = tolower(ApplicationNameL[i]);
}
std::vector <std::string> pixmaps;
pixmaps.push_back(std::string() + PIXMAPS + "/" + FullGameName + ".png");
pixmaps.push_back(std::string() + PIXMAPS + "/" + FullGameNameL + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + FullGameName + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + FullGameNameL + ".png");
pixmaps.push_back(std::string() + PIXMAPS + "/" + ApplicationName + ".png");
pixmaps.push_back(std::string() + PIXMAPS + "/" + ApplicationNameL + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + ApplicationName + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + ApplicationNameL + ".png");
pixmaps.push_back(std::string() + PIXMAPS + "/" + "Stratagus" + ".png");
pixmaps.push_back(std::string() + PIXMAPS + "/" + "stratagus" + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + "Stratagus" + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + "stratagus" + ".png");
for (size_t i = 0; i < pixmaps.size(); ++i) {
if (stat(pixmaps[i].c_str(), &st) == 0) {
if (g) { CGraphic::Free(g); }
g = CGraphic::New(pixmaps[i].c_str());
g->Load();
icon = g->Surface;
if (icon) { break; }
}
}
if (icon) {
SDL_WM_SetIcon(icon, 0);
}
if (g) {
CGraphic::Free(g);
}
#if defined(USE_OPENGL) || defined(USE_GLES)
UseOpenGL = UseOpenGL_orig;
#endif
#endif
#ifdef USE_WIN32
HWND hwnd = NULL;
HICON hicon = NULL;
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
if (SDL_GetWMInfo(&info)) {
hwnd = info.window;
}
if (hwnd) {
hicon = ExtractIcon(GetModuleHandle(NULL), Parameters::Instance.applicationName.c_str(), 0);
}
if (hicon) {
SendMessage(hwnd, (UINT)WM_SETICON, ICON_SMALL, (LPARAM)hicon);
SendMessage(hwnd, (UINT)WM_SETICON, ICON_BIG, (LPARAM)hicon);
}
#endif
}
// Initialize the display
#if !defined(USE_OPENGL) && !defined(USE_GLES)
flags = SDL_HWSURFACE | SDL_HWPALETTE;
#endif
// Sam said: better for windows.
/* SDL_HWSURFACE|SDL_HWPALETTE | */
if (Video.FullScreen) {
flags |= SDL_FULLSCREEN;
}
#if defined(USE_OPENGL) || defined(USE_GLES)
if (UseOpenGL) {
#ifdef USE_GLES_NATIVE
flags |= SDL_OPENGLES;
#endif
#ifdef USE_OPENGL
flags |= SDL_OPENGL | SDL_GL_DOUBLEBUFFER;
#endif
}
#endif
if (!Video.Width || !Video.Height) {
Video.Width = 640;
Video.Height = 480;
}
if (!Video.Depth) {
Video.Depth = 32;
}
#if defined(USE_OPENGL) || defined(USE_GLES)
if (!Video.ViewportWidth || !Video.ViewportHeight) {
Video.ViewportWidth = Video.Width;
Video.ViewportHeight = Video.Height;
}
TheScreen = SDL_SetVideoMode(Video.ViewportWidth, Video.ViewportHeight, Video.Depth, flags);
#else
TheScreen = SDL_SetVideoMode(Video.Width, Video.Height, Video.Depth, flags);
#endif
if (TheScreen && (TheScreen->format->BitsPerPixel != 16
&& TheScreen->format->BitsPerPixel != 32)) {
// Only support 16 and 32 bpp, default to 16
#if defined(USE_OPENGL) || defined(USE_GLES)
TheScreen = SDL_SetVideoMode(Video.ViewportWidth, Video.ViewportHeight, 16, flags);
#else
TheScreen = SDL_SetVideoMode(Video.Width, Video.Height, 16, flags);
#endif
}
if (TheScreen == NULL) {
fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n",
Video.Width, Video.Height, Video.Depth, SDL_GetError());
exit(1);
}
Video.FullScreen = (TheScreen->flags & SDL_FULLSCREEN) ? 1 : 0;
Video.Depth = TheScreen->format->BitsPerPixel;
#if defined(USE_TOUCHSCREEN) && defined(USE_WIN32)
// Must not allow SDL to switch to relative mouse coordinates
// with touchscreen when going fullscreen. So we don't hide the
// cursor, but instead set a transparent 1px cursor
Uint8 emptyCursor[] = {'\0'};
Video.blankCursor = SDL_CreateCursor(emptyCursor, emptyCursor, 1, 1, 0, 0);
SDL_SetCursor(Video.blankCursor);
#else
// Turn cursor off, we use our own.
SDL_ShowCursor(SDL_DISABLE);
#endif
// Make default character translation easier
SDL_EnableUNICODE(1);
#if defined(USE_OPENGL) || defined(USE_GLES)
if (UseOpenGL) {
#ifdef USE_GLES_EGL
// Get the SDL window handle
SDL_SysWMinfo sysInfo; //Will hold our Window information
SDL_VERSION(&sysInfo.version); //Set SDL version
if (SDL_GetWMInfo(&sysInfo) <= 0) {
fprintf(stderr, "Unable to get window handle\n");
exit(1);
}
eglDisplay = eglGetDisplay((EGLNativeDisplayType)sysInfo.info.x11.display);
if (!eglDisplay) {
fprintf(stderr, "Couldn't open EGL Display\n");
exit(1);
}
if (!eglInitialize(eglDisplay, NULL, NULL)) {
fprintf(stderr, "Couldn't initialize EGL Display\n");
exit(1);
}
// Find a matching config
EGLint configAttribs[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_NONE};
EGLint numConfigsOut = 0;
EGLConfig eglConfig;
if (eglChooseConfig(eglDisplay, configAttribs, &eglConfig, 1, &numConfigsOut) != EGL_TRUE || numConfigsOut == 0) {
fprintf(stderr, "Unable to find appropriate EGL config\n");
exit(1);
}
eglSurface = eglCreateWindowSurface(eglDisplay, eglConfig, (EGLNativeWindowType)sysInfo.info.x11.window, 0);
if (eglSurface == EGL_NO_SURFACE) {
fprintf(stderr, "Unable to create EGL surface\n");
exit(1);
}
// Bind GLES and create the context
eglBindAPI(EGL_OPENGL_ES_API);
EGLint contextParams[] = {EGL_CONTEXT_CLIENT_VERSION, 1, EGL_NONE};
EGLContext eglContext = eglCreateContext(eglDisplay, eglConfig, NULL, NULL);
if (eglContext == EGL_NO_CONTEXT) {
fprintf(stderr, "Unable to create GLES context\n");
exit(1);
}
if (eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext) == EGL_FALSE) {
fprintf(stderr, "Unable to make GLES context current\n");
exit(1);
}
#endif
InitOpenGL();
}
#endif
InitKey2Str();
ColorBlack = Video.MapRGB(TheScreen->format, 0, 0, 0);
ColorDarkGreen = Video.MapRGB(TheScreen->format, 48, 100, 4);
ColorLightBlue = Video.MapRGB(TheScreen->format, 52, 113, 166);
ColorBlue = Video.MapRGB(TheScreen->format, 0, 0, 252);
ColorOrange = Video.MapRGB(TheScreen->format, 248, 140, 20);
ColorWhite = Video.MapRGB(TheScreen->format, 252, 248, 240);
ColorLightGray = Video.MapRGB(TheScreen->format, 192, 192, 192);
ColorGray = Video.MapRGB(TheScreen->format, 128, 128, 128);
ColorDarkGray = Video.MapRGB(TheScreen->format, 64, 64, 64);
ColorRed = Video.MapRGB(TheScreen->format, 252, 0, 0);
ColorGreen = Video.MapRGB(TheScreen->format, 0, 252, 0);
ColorYellow = Video.MapRGB(TheScreen->format, 252, 252, 0);
UI.MouseWarpPos.x = UI.MouseWarpPos.y = -1;
}
// Prepare for creation of the OpenGL context
//
int _glfwCreateContext(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
int attribs[40];
EGLConfig config;
EGLContext share = NULL;
if (ctxconfig->share)
share = ctxconfig->share->egl.context;
if (!chooseFBConfigs(ctxconfig, fbconfig, &config))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to find a suitable EGLConfig");
return GL_FALSE;
}
#if defined(_GLFW_X11)
// Retrieve the visual corresponding to the chosen EGL config
{
EGLint count = 0;
int mask;
EGLint redBits, greenBits, blueBits, alphaBits, visualID = 0;
XVisualInfo info;
eglGetConfigAttrib(_glfw.egl.display, config,
EGL_NATIVE_VISUAL_ID, &visualID);
info.screen = _glfw.x11.screen;
mask = VisualScreenMask;
if (visualID)
{
// The X window visual must match the EGL config
info.visualid = visualID;
mask |= VisualIDMask;
}
else
{
// some EGL drivers don't implement the EGL_NATIVE_VISUAL_ID
// attribute, so attempt to find the closest match.
eglGetConfigAttrib(_glfw.egl.display, config,
EGL_RED_SIZE, &redBits);
eglGetConfigAttrib(_glfw.egl.display, config,
EGL_GREEN_SIZE, &greenBits);
eglGetConfigAttrib(_glfw.egl.display, config,
EGL_BLUE_SIZE, &blueBits);
eglGetConfigAttrib(_glfw.egl.display, config,
EGL_ALPHA_SIZE, &alphaBits);
info.depth = redBits + greenBits + blueBits + alphaBits;
mask |= VisualDepthMask;
}
window->egl.visual = XGetVisualInfo(_glfw.x11.display,
mask, &info, &count);
if (window->egl.visual == NULL)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to retrieve visual for EGLConfig");
return GL_FALSE;
}
}
#endif // _GLFW_X11
if (ctxconfig->api == GLFW_OPENGL_ES_API)
{
if (!eglBindAPI(EGL_OPENGL_ES_API))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to bind OpenGL ES: %s",
getErrorString(eglGetError()));
return GL_FALSE;
}
}
else
{
if (!eglBindAPI(EGL_OPENGL_API))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to bind OpenGL: %s",
getErrorString(eglGetError()));
return GL_FALSE;
}
}
if (_glfw.egl.KHR_create_context)
{
int index = 0, mask = 0, flags = 0, strategy = 0;
if (ctxconfig->api == GLFW_OPENGL_API)
{
if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE)
mask |= EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE)
mask |= EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
if (ctxconfig->forward)
flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
if (ctxconfig->debug)
flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
}
if (ctxconfig->robustness != GLFW_NO_ROBUSTNESS)
{
if (ctxconfig->robustness == GLFW_NO_RESET_NOTIFICATION)
strategy = EGL_NO_RESET_NOTIFICATION_KHR;
else if (ctxconfig->robustness == GLFW_LOSE_CONTEXT_ON_RESET)
strategy = EGL_LOSE_CONTEXT_ON_RESET_KHR;
flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
}
if (ctxconfig->major != 1 || ctxconfig->minor != 0)
{
setEGLattrib(EGL_CONTEXT_MAJOR_VERSION_KHR, ctxconfig->major);
setEGLattrib(EGL_CONTEXT_MINOR_VERSION_KHR, ctxconfig->minor);
}
if (mask)
setEGLattrib(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, mask);
if (flags)
setEGLattrib(EGL_CONTEXT_FLAGS_KHR, flags);
if (strategy)
setEGLattrib(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, strategy);
setEGLattrib(EGL_NONE, EGL_NONE);
}
else
{
int index = 0;
if (ctxconfig->api == GLFW_OPENGL_ES_API)
setEGLattrib(EGL_CONTEXT_CLIENT_VERSION, ctxconfig->major);
setEGLattrib(EGL_NONE, EGL_NONE);
}
window->egl.context = eglCreateContext(_glfw.egl.display,
config, share, attribs);
if (window->egl.context == EGL_NO_CONTEXT)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to create context: %s",
getErrorString(eglGetError()));
return GL_FALSE;
}
window->egl.config = config;
return GL_TRUE;
}
void THEGLInit(THApplicaation* state)
{
eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
EGLint eglMajor,eglMinor;
eglInitialize(eglDisplay, &eglMajor,&eglMinor);
THLog("EGL Initialization : %d.%d",eglMajor,eglMinor);
const EGLint attribs[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
#if USE_DEPTH_BUFFER==1
EGL_DEPTH_SIZE,8,
#endif
EGL_NONE
};
EGLint numConfigs;
EGLConfig config;
eglChooseConfig(eglDisplay, attribs, &config, 1, &numConfigs);
#if THPLATFORM==THPLATFORM_ANDROID
EGLint format;
eglGetConfigAttrib(eglDisplay, config, EGL_NATIVE_VISUAL_ID, &format);
ANativeWindow_setBuffersGeometry(state->window, 0, 0, format);
eglSurface = eglCreateWindowSurface(eglDisplay, config, (EGLNativeWindowType)(state->window), NULL);
#elif THPLATFORM==THPLATFORM_WINDOWS
eglSurface = eglCreateWindowSurface(eglDisplay, config, *state, NULL);
if(eglSurface == EGL_NO_SURFACE)
{
eglGetError(); // Clear error
eglSurface = eglCreateWindowSurface(eglDisplay, config, NULL, NULL);
}
#endif
const EGLint attrib_list[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
eglContext = eglCreateContext(eglDisplay, config, NULL, attrib_list);
#if THPLATFORM==THPLATFORM_WINDOWS
eglBindAPI(EGL_OPENGL_ES_API);
#endif
if (eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext) == EGL_FALSE) {
THError("Unable to eglMakeCurrent");
assert(0);
return;
}
EGLint sw,sh;
eglQuerySurface(eglDisplay, eglSurface, EGL_WIDTH, &sw);
eglQuerySurface(eglDisplay, eglSurface, EGL_HEIGHT, &sh);
windowWidthi=sw;
windowHeighti=sh;
windowSize.Set((float)sw,(float)sh);
gameScale.Set(0.0f,0.0f);
}
static bool gfx_ctx_qnx_init(void *data)
{
EGLint num_config;
EGLint egl_version_major, egl_version_minor;
EGLint context_attributes[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
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
};
int angle, size[2];
int usage, format = SCREEN_FORMAT_RGBX8888;
/* 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;
}
}
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, &g_config, 1, &num_config))
goto error;
g_egl_ctx = eglCreateContext(g_egl_dpy, g_config, EGL_NO_CONTEXT, context_attributes);
if (g_egl_ctx == EGL_NO_CONTEXT)
goto error;
if (g_use_hw_ctx)
{
g_egl_hw_ctx = eglCreateContext(g_egl_dpy, g_config, g_egl_ctx,
context_attributes);
RARCH_LOG("[Android/EGL]: Created shared context: %p.\n", (void*)g_egl_hw_ctx);
if (g_egl_hw_ctx == EGL_NO_CONTEXT)
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
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;
}
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, g_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
glamor_egl_init(ScrnInfoPtr scrn, int fd)
{
struct glamor_egl_screen_private *glamor_egl;
const char *version;
EGLint config_attribs[] = {
#ifdef GLAMOR_GLES2
EGL_CONTEXT_CLIENT_VERSION, 2,
#endif
EGL_NONE
};
glamor_identify(0);
glamor_egl = calloc(sizeof(*glamor_egl), 1);
if (glamor_egl == NULL)
return FALSE;
if (xf86GlamorEGLPrivateIndex == -1)
xf86GlamorEGLPrivateIndex = xf86AllocateScrnInfoPrivateIndex();
scrn->privates[xf86GlamorEGLPrivateIndex].ptr = glamor_egl;
glamor_egl->fd = fd;
#ifdef GLAMOR_HAS_GBM
glamor_egl->gbm = gbm_create_device(glamor_egl->fd);
if (glamor_egl->gbm == NULL) {
ErrorF("couldn't get display device\n");
return FALSE;
}
glamor_egl->display = eglGetDisplay(glamor_egl->gbm);
#else
glamor_egl->display = eglGetDisplay((EGLNativeDisplayType) (intptr_t) fd);
#endif
glamor_egl->has_gem = glamor_egl_check_has_gem(fd);
#ifndef GLAMOR_GLES2
eglBindAPI(EGL_OPENGL_API);
#else
eglBindAPI(EGL_OPENGL_ES_API);
#endif
if (!eglInitialize
(glamor_egl->display, &glamor_egl->major, &glamor_egl->minor)) {
xf86DrvMsg(scrn->scrnIndex, X_ERROR, "eglInitialize() failed\n");
return FALSE;
}
version = eglQueryString(glamor_egl->display, EGL_VERSION);
xf86Msg(X_INFO, "%s: EGL version %s:\n", glamor_name, version);
#define GLAMOR_CHECK_EGL_EXTENSION(EXT) \
if (!glamor_egl_has_extension(glamor_egl, "EGL_" #EXT)) { \
ErrorF("EGL_" #EXT " required.\n"); \
return FALSE; \
}
#define GLAMOR_CHECK_EGL_EXTENSIONS(EXT1, EXT2) \
if (!glamor_egl_has_extension(glamor_egl, "EGL_" #EXT1) && \
!glamor_egl_has_extension(glamor_egl, "EGL_" #EXT2)) { \
ErrorF("EGL_" #EXT1 " or EGL_" #EXT2 " required.\n"); \
return FALSE; \
}
GLAMOR_CHECK_EGL_EXTENSION(MESA_drm_image);
GLAMOR_CHECK_EGL_EXTENSION(KHR_gl_renderbuffer_image);
#ifdef GLAMOR_GLES2
GLAMOR_CHECK_EGL_EXTENSIONS(KHR_surfaceless_context, KHR_surfaceless_gles2);
#else
GLAMOR_CHECK_EGL_EXTENSIONS(KHR_surfaceless_context,
KHR_surfaceless_opengl);
#endif
#ifdef GLAMOR_HAS_GBM
if (glamor_egl_has_extension(glamor_egl, "EGL_KHR_gl_texture_2D_image") &&
glamor_egl_has_extension(glamor_egl, "EGL_EXT_image_dma_buf_import"))
glamor_egl->dri3_capable = TRUE;
#endif
glamor_egl->context = eglCreateContext(glamor_egl->display,
NULL, EGL_NO_CONTEXT,
config_attribs);
if (glamor_egl->context == EGL_NO_CONTEXT) {
xf86DrvMsg(scrn->scrnIndex, X_ERROR, "Failed to create EGL context\n");
return FALSE;
}
if (!eglMakeCurrent(glamor_egl->display,
EGL_NO_SURFACE, EGL_NO_SURFACE, glamor_egl->context)) {
xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Failed to make EGL context current\n");
return FALSE;
}
glamor_egl->saved_free_screen = scrn->FreeScreen;
scrn->FreeScreen = glamor_egl_free_screen;
#ifdef GLAMOR_GLES2
xf86DrvMsg(scrn->scrnIndex, X_INFO, "Using GLES2.\n");
xf86DrvMsg(scrn->scrnIndex, X_WARNING,
"Glamor is using GLES2 but GLX needs GL. "
"Indirect GLX may not work correctly.\n");
#endif
return TRUE;
}
bool GLES20Context::Init(EngWindow* pWindow)
{
eglDisplay = eglGetDisplay(pWindow->GetDisplay());
/*
Step 2 - Initialize EGL.
EGL has to be initialized with the display obtained in the
previous step. We cannot use other EGL functions except
eglGetDisplay and eglGetError before eglInitialize has been
called.
If we're not interested in the EGL version number we can just
pass NULL for the second and third parameters.
*/
EGLint iMajorVersion, iMinorVersion;
if (!eglInitialize(eglDisplay, &iMajorVersion, &iMinorVersion))
{
printf("Error: eglInitialize() failed.\n");
return false;
}
/*
Step 3 - Make OpenGL ES the current API.
EGL provides ways to set up OpenGL ES and OpenVG contexts
(and possibly other graphics APIs in the future), so we need
to specify the "current API".
*/
eglBindAPI(EGL_OPENGL_ES_API);
if (!TestEGLError("eglBindAPI"))
{
return false;
}
/*
Step 4 - Specify the required configuration attributes.
An EGL "configuration" describes the pixel format and type of
surfaces that can be used for drawing.
For now we just want to use a 16 bit RGB surface that is a
Window surface, i.e. it will be visible on screen. The list
has to contain key/value pairs, terminated with EGL_NONE.
*/
EGLint pi32ConfigAttribs[7];
pi32ConfigAttribs[0] = EGL_SURFACE_TYPE;
pi32ConfigAttribs[1] = EGL_WINDOW_BIT;
pi32ConfigAttribs[2] = EGL_RENDERABLE_TYPE;
pi32ConfigAttribs[3] = EGL_OPENGL_ES2_BIT;
pi32ConfigAttribs[4] = EGL_DEPTH_SIZE;
pi32ConfigAttribs[5] = 16;
pi32ConfigAttribs[6] = EGL_NONE;
/*
Step 5 - Find a config that matches all requirements.
eglChooseConfig provides a list of all available configurations
that meet or exceed the requirements given as the second
argument. In most cases we just want the first config that meets
all criteria, so we can limit the number of configs returned to 1.
*/
EGLint iConfigs;
if (!eglChooseConfig(eglDisplay, pi32ConfigAttribs, &eglConfig, 1, &iConfigs) || (iConfigs != 1))
{
printf("Error: eglChooseConfig() failed.\n");
return false;
}
/*
Step 6 - Create a surface to draw to.
Use the config picked in the previous step and the native window
handle when available to create a window surface. A window surface
is one that will be visible on screen inside the native display (or
fullscreen if there is no windowing system).
Pixmaps and pbuffers are surfaces which only exist in off-screen
memory.
*/
eglSurface = eglCreateWindowSurface(eglDisplay, eglConfig, pWindow->GetWindow(), NULL);
if (!TestEGLError("eglCreateWindowSurface"))
{
return false;
}
/*
Step 7 - Create a context.
*/
eglContext = eglCreateContext(eglDisplay, eglConfig, NULL, ai32ContextAttribs);
if (!TestEGLError("eglCreateContext"))
{
return false;
}
/*
Step 8 - Bind the context to the current thread and use our
window surface for drawing and reading.
Contexts are bound to a thread. This means you don't have to
worry about other threads and processes interfering with your
OpenGL ES application.
We need to specify a surface that will be the target of all
subsequent drawing operations, and one that will be the source
of read operations. They can be the same surface.
*/
eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);
if (!TestEGLError("eglMakeCurrent"))
{
return false;
}
/*
Step 9 - Draw something with OpenGL ES.
At this point everything is initialized and we're ready to use
OpenGL ES to draw something on the screen.
*/
return true;
}
EGLContext EGLDisplayOpenVG::contextForSurface(const EGLSurface& surface)
{
ASSERT(surface != EGL_NO_SURFACE);
if (m_platformSurfaces.contains(surface))
return m_platformSurfaces.get(surface)->eglContext();
eglBindAPI(EGL_OPENVG_API);
ASSERT_EGL_NO_ERROR();
if (!m_sharedPlatformSurface) // shared context has not been created yet
sharedPlatformSurface(); // creates the shared surface & context
EGLint surfaceConfigId;
if (m_surfaceConfigIds.contains(surface))
surfaceConfigId = m_surfaceConfigIds.get(surface);
else {
// Retrieve the same EGL config for context creation that was used to
// create the the EGL surface.
EGLBoolean success = eglQuerySurface(m_display, surface, EGL_CONFIG_ID, &surfaceConfigId);
ASSERT(success == EGL_TRUE);
ASSERT(surfaceConfigId != EGL_BAD_ATTRIBUTE);
m_surfaceConfigIds.set(surface, surfaceConfigId);
}
if (m_compatibleConfigIds.contains(surfaceConfigId))
surfaceConfigId = m_compatibleConfigIds.get(surfaceConfigId);
if (m_contexts.contains(surfaceConfigId))
return m_contexts.get(surfaceConfigId);
EGLDisplay currentDisplay = eglGetCurrentDisplay();
EGLSurface currentReadSurface = eglGetCurrentSurface(EGL_READ);
EGLSurface currentDrawSurface = eglGetCurrentSurface(EGL_DRAW);
EGLContext currentContext = eglGetCurrentContext();
// Before creating a new context, let's try whether an existing one
// is compatible with the surface. EGL doesn't give us a different way
// to check context/surface compatibility than trying it out, so let's
// do just that.
HashMap<EGLint, EGLContext>::iterator end = m_contexts.end();
for (HashMap<EGLint, EGLContext>::iterator it = m_contexts.begin(); it != end; ++it) {
eglMakeCurrent(m_display, surface, surface, (*it).second);
if (eglGetError() == EGL_SUCCESS) {
// Restore previous surface/context.
if (currentContext != EGL_NO_CONTEXT) {
eglMakeCurrent(currentDisplay, currentReadSurface, currentDrawSurface, currentContext);
ASSERT_EGL_NO_ERROR();
}
// Cool, surface is compatible to one of our existing contexts.
m_compatibleConfigIds.set(surfaceConfigId, (*it).first);
return (*it).second;
}
}
// Restore previous surface/context.
if (currentContext != EGL_NO_CONTEXT) {
eglMakeCurrent(currentDisplay, currentReadSurface, currentDrawSurface, currentContext);
ASSERT_EGL_NO_ERROR();
}
EGLConfig config;
EGLint numConfigs;
const EGLint configAttribs[] = {
EGL_CONFIG_ID, surfaceConfigId,
EGL_NONE
};
eglChooseConfig(m_display, configAttribs, &config, 1, &numConfigs);
ASSERT_EGL_NO_ERROR();
ASSERT(numConfigs == 1);
// We share all of the images and paths amongst the different contexts,
// so that they can be used in all of them. Resources that are created
// while m_sharedPlatformSurface->context() is current will be
// accessible from all other contexts, but are not restricted to the
// lifetime of those contexts.
EGLContext context = eglCreateContext(m_display, config, m_sharedPlatformSurface->eglContext(), 0);
ASSERT_EGL_NO_ERROR();
ASSERT(!m_contexts.contains(surfaceConfigId));
m_contexts.set(surfaceConfigId, context);
return context;
}
int initOpenGL(int device_id)
{
if (is_initialized)
return 1;
// desired config
const EGLint configAttribs[] = {
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_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER,
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
EGL_NONE
};
EGLDeviceEXT eglDevs[MAX_DEVICES];
EGLint numDevices;
PFNEGLQUERYDEVICESEXTPROC eglQueryDevicesEXT =
(PFNEGLQUERYDEVICESEXTPROC)
eglGetProcAddress("eglQueryDevicesEXT");
eglQueryDevicesEXT(MAX_DEVICES, eglDevs, &numDevices);
printf("Found %d GPUs for rendering. Using device %d.\n", numDevices, device_id);
if (device_id >= numDevices) {
printf("Device id outside of range of available devices.\n");
return -1;
}
PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT =
(PFNEGLGETPLATFORMDISPLAYEXTPROC)
eglGetProcAddress("eglGetPlatformDisplayEXT");
if (eglGetPlatformDisplayEXT == NULL) {
printf("Failed to get eglGetPlatformDisplayEXT\n");
return -2;
}
EGLDisplay eglDpy = eglGetPlatformDisplayEXT(
EGL_PLATFORM_DEVICE_EXT, eglDevs[device_id], 0);
// get default display
// EGLDisplay eglDpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (eglDpy == EGL_NO_DISPLAY) {
printf("Could not get EGL display\n");
return -3;
}
// initialize
EGLint major, minor;
if (eglInitialize(eglDpy, &major, &minor) != EGL_TRUE) {
printf("Could not initialize EGL\n");
return -4;
}
// choose config
EGLint numConfigs;
EGLConfig eglCfg;
if (eglChooseConfig(eglDpy, configAttribs, &eglCfg, 1, &numConfigs)!=EGL_TRUE ) {
printf("Could not choose EGL config\n");
return -5;
}
// bind OpenGL API
if( eglBindAPI(EGL_OPENGL_API)!=EGL_TRUE ) {
printf("Could not bind EGL OpenGL API\n");
return -6;
}
// create context
EGLContext eglCtx = eglCreateContext(eglDpy, eglCfg, EGL_NO_CONTEXT, NULL);
if( eglCtx==EGL_NO_CONTEXT ) {
printf("Could not create EGL context\n");
return -7;
}
// make context current, no surface (let OpenGL handle FBO)
if( eglMakeCurrent(eglDpy, EGL_NO_SURFACE, EGL_NO_SURFACE, eglCtx)!=EGL_TRUE ) {
eglDestroyContext(eglDpy, eglCtx);
printf("Could not make EGL context current\n");
return -8;
}
is_initialized = 1;
return 1;
}
static void
init_egl(struct display *display, struct window *window)
{
static const EGLint context_attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
const char *extensions;
EGLint config_attribs[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
EGLint major, minor, n, count, i, size;
EGLConfig *configs;
EGLBoolean ret;
if (window->opaque || window->buffer_size == 16)
config_attribs[9] = 0;
display->egl.dpy = eglGetDisplay(display->display);
assert(display->egl.dpy);
ret = eglInitialize(display->egl.dpy, &major, &minor);
assert(ret == EGL_TRUE);
ret = eglBindAPI(EGL_OPENGL_ES_API);
assert(ret == EGL_TRUE);
if (!eglGetConfigs(display->egl.dpy, NULL, 0, &count) || count < 1)
assert(0);
configs = calloc(count, sizeof *configs);
assert(configs);
ret = eglChooseConfig(display->egl.dpy, config_attribs,
configs, count, &n);
assert(ret && n >= 1);
for (i = 0; i < n; i++) {
eglGetConfigAttrib(display->egl.dpy,
configs[i], EGL_BUFFER_SIZE, &size);
if (window->buffer_size == size) {
display->egl.conf = configs[i];
break;
}
}
free(configs);
if (display->egl.conf == NULL) {
fprintf(stderr, "did not find config with buffer size %d\n",
window->buffer_size);
exit(EXIT_FAILURE);
}
display->egl.ctx = eglCreateContext(display->egl.dpy,
display->egl.conf,
EGL_NO_CONTEXT, context_attribs);
assert(display->egl.ctx);
display->swap_buffers_with_damage = NULL;
extensions = eglQueryString(display->egl.dpy, EGL_EXTENSIONS);
if (extensions &&
strstr(extensions, "EGL_EXT_swap_buffers_with_damage") &&
strstr(extensions, "EGL_EXT_buffer_age"))
display->swap_buffers_with_damage =
(PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)
eglGetProcAddress("eglSwapBuffersWithDamageEXT");
if (display->swap_buffers_with_damage)
printf("has EGL_EXT_buffer_age and EGL_EXT_swap_buffers_with_damage\n");
}
// -----------------------------------------------------------------------------
WindowOffscreenEGL::WindowOffscreenEGL(int width, int height)
: WindowBase(width, height)
, m_display(EGL_NO_DISPLAY)
, m_context(EGL_NO_CONTEXT)
, m_surface(EGL_NO_SURFACE)
, m_stream(EGL_NO_STREAM_KHR)
, m_offscreen(true)
{
eglGetPlatformDisplayEXT =
(PFNEGLGETPLATFORMDISPLAYEXTPROC)eglGetProcAddress("eglGetPlatformDisplayEXT");
eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)eglGetProcAddress("eglQueryDevicesEXT");
eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC)eglGetProcAddress("eglQueryDeviceStringEXT");
eglGetOutputLayersEXT = (PFNEGLGETOUTPUTLAYERSEXTPROC)eglGetProcAddress("eglGetOutputLayersEXT");
eglCreateStreamKHR = (PFNEGLCREATESTREAMKHRPROC)eglGetProcAddress("eglCreateStreamKHR");
eglDestroyStreamKHR = (PFNEGLDESTROYSTREAMKHRPROC)eglGetProcAddress("eglDestroyStreamKHR");
eglCreateStreamProducerSurfaceKHR =
(PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC)eglGetProcAddress("eglCreateStreamProducerSurfaceKHR");
eglStreamConsumerOutputEXT =
(PFNEGLSTREAMCONSUMEROUTPUTEXTPROC)eglGetProcAddress("eglStreamConsumerOutputEXT");
if (!eglGetPlatformDisplayEXT || !eglQueryDevicesEXT || !eglQueryDeviceStringEXT) {
std::cout << "WindowEGL: Cannot load EGL extensions: eglGetPlatformDisplayEXT,"
<< " eglQueryDevicesEXT, eglQueryDeviceStringEXT" << std::endl;
throw std::exception();
}
EGLBoolean status;
EGLint deviceCount = 4;
EGLint foundDevices = 0;
EGLDeviceEXT devices[deviceCount];
// -----------------------
std::cout << "WindowEGL: find EGL devices" << std::endl;
{
// Get pointers of required EGL functions
status = eglQueryDevicesEXT(deviceCount, devices, &foundDevices);
if (status != EGL_TRUE) {
std::cout << "WindowEGL: Failed to query devices (error: "
<< std::hex << eglGetError() << ")" << std::dec << std::endl;
throw std::exception();
}
std::cout << "WindowEGL: found " << foundDevices << " EGL devices" << std::endl;
}
EGLAttrib layerAttribs[] = {
EGL_NONE, EGL_NONE,
EGL_NONE, EGL_NONE,
};
// -----------------------
if (m_offscreen == false) {
// get device name to setup DRM, assume that devices[0] is the one to use
const char *drmName = eglQueryDeviceStringEXT(devices[0], EGL_DRM_DEVICE_FILE_EXT);
if (!drmName) {
std::cout << "WindowEGL: unable to query DRM device name" << std::endl;
} else {
std::cout << "WindowEGL: use drm device: " << drmName << std::endl;
}
std::cout << "WindowEGL: init DRM with " << width << "x" << height << " resolution" << std::endl;
if (!initDrm(drmName, layerAttribs, m_width, m_height)) {
std::cout << "WindowEGL: Failed to init DRM" << std::endl;
throw std::exception();
}
std::cout << "WindowEGL: DRM initialized, selected resolution is "
<< m_width
<< ", "
<< m_height
<< std::endl;
}
// -----------------------
std::cout << "WindowEGL: init EGL with GLES3 context" << std::endl;
{
EGLenum platform = EGL_PLATFORM_DEVICE_EXT;
EGLint dispAttribs[] = {EGL_NONE, EGL_NONE};
// create display on top of DRM display
m_display = eglGetPlatformDisplayEXT(platform, (NativeDisplayType)devices[0], dispAttribs);
if (m_display == EGL_NO_DISPLAY) {
std::cout << "WindowEGL: Failed to create EGL display: "
<< "eglGetPlatformDisplayEXT failed with: "
<< std::hex << eglGetError() << std::dec << std::endl;
throw std::exception();
}
// setup EGL like in windowing system
status = eglInitialize(m_display, 0, 0);
if (!status) {
eglTerminate(m_display);
m_display = EGL_NO_DISPLAY;
std::cout << "WindowEGL: Could not init EGL eglInitialize failed with: "
<< std::hex << eglGetError() << std::dec << std::endl;
throw std::exception();
}
std::cout << "WindowEGL: bind OpenGLES3 API" << std::endl;
EGLint cfgAttribs[] = {
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT | EGL_STREAM_BIT_KHR,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT,
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 8,
//EGL_STENCIL_SIZE, 8,
EGL_NONE, EGL_NONE};
EGLint cfgCount = 0;
status = eglChooseConfig(m_display, cfgAttribs, &m_config, 1, &cfgCount);
if (!status || cfgCount == 0) {
std::cout << "Could not read EGL config count! error: 0x"
<< std::hex << eglGetError() << std::dec << std::endl;
throw std::exception();
}
// in offscreen mode we use Pbuffer surface to manage GL context
if (m_offscreen == true) {
std::cout << "WindowEGL: offscreen mode -> use EGL PBuffer surface "
<< m_width << "x" << m_height << std::endl;
EGLint pbsAttrib[] = {
EGL_WIDTH, m_width,
EGL_HEIGHT, m_height,
//EGL_MIPMAP_TEXTURE, EGL_TRUE,
//EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA,
//EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
EGL_NONE, EGL_NONE};
m_surface = eglCreatePbufferSurface(m_display, m_config, pbsAttrib);
// in onscreen mode we pass GL output through EGL stream directly to display device
} else {
std::cout << "WindowEGL: onscreen mode -> use EGL stream to display" << std::endl;
EGLOutputLayerEXT layer;
int n;
if (!eglGetOutputLayersEXT(m_display, layerAttribs, &layer, 1, &n) || !n) {
std::cout << "WindowEGL: Unable to get output layer" << std::endl;
throw std::exception();
}
// Create a stream and connect to the output
EGLint stream_attr[] = {
EGL_STREAM_FIFO_LENGTH_KHR, 1,
EGL_NONE};
m_stream = eglCreateStreamKHR(m_display, stream_attr);
if (m_stream == EGL_NO_STREAM_KHR) {
std::cout << "WindowEGL: Unable to create stream" << std::endl;
throw std::exception();
}
if (!eglStreamConsumerOutputEXT(m_display, m_stream, layer)) {
std::cout << "Unable to connect output to stream" << std::endl;
return;
}
EGLint srfAttribs[] = {
EGL_WIDTH, m_width,
EGL_HEIGHT, m_height,
EGL_NONE, EGL_NONE};
// create a surface as EGL stream producer
m_surface = eglCreateStreamProducerSurfaceKHR(m_display, m_config, m_stream, srfAttribs);
}
if (m_surface == EGL_NO_SURFACE) {
std::cout << "WindowEGL: Could not create rendering surface: 0x"
<< std::hex << eglGetError() << std::dec << std::endl;
throw std::exception();
}
eglBindAPI(EGL_OPENGL_ES_API);
}
// -----------------------
std::cout << "WindowEGL: create EGL context" << std::endl;
{
EGLint ctxAttribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 3,
EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_FALSE,
EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_NO_RESET_NOTIFICATION_EXT,
EGL_NONE, EGL_NONE};
m_context = eglCreateContext(m_display, m_config, EGL_NO_CONTEXT, ctxAttribs);
if (m_context == EGL_NO_CONTEXT) {
std::cout << "WindowEGL: Failed to create EGL context" << std::endl;
throw std::exception();
}
}
// -----------------------
std::cout << "WindowEGL: assign EGL context to current thread" << std::endl;
{
status = eglMakeCurrent(m_display, m_surface, m_surface, m_context);
if (status == EGL_FALSE) {
std::cout << "WindowEGL: Could not makeCurrent: "
<< std::hex << eglGetError() << std::dec << std::endl;
throw std::exception();
}
}
}
GLOffscreenBuffer::GLOffscreenBuffer(unsigned width, unsigned height)
: m_width(width)
, m_height(height)
, m_display(0)
, m_context(0)
, m_surface(0)
{
m_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (!m_display) {
cerr << "Error: eglGetDisplay()\n";
return;
}
if (!eglInitialize(m_display, 0, 0)) {
cerr << "Error: eglInitialize()\n";
return;
}
static const EGLint attributes[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 24,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
EGLConfig config;
EGLint configCount;
if (!eglChooseConfig(m_display, attributes, &config, 1, &configCount)) {
cerr << "Error: eglChooseConfig()\n";
return;
}
if (configCount != 1) {
cerr << "Error: couldn't get a valid config for EGL\n";
return;
}
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
cerr << "Error: eglBindAPI()\n";
return;
}
m_context = eglCreateContext(m_display, config, EGL_NO_CONTEXT, 0);
if (!m_context) {
cerr << "Error: eglCreateContext()\n";
return;
}
static const EGLint surfaceAttributes[] = {
EGL_WIDTH, width,
EGL_HEIGHT, height,
EGL_NONE
};
m_surface = eglCreatePbufferSurface(m_display, config, surfaceAttributes);
if (!m_surface) {
cerr << "Error: eglCreatePbufferSurface()\n";
return;
}
}
HWND gkDeviceRenderContext::initDevice(ISystemInitInfo& sii)
{
//////////////////////////////////////////////////////////////////////////
// native create ogles2 device
int bDone;
m_NDT = 0;//(EGLNativeDisplayType)OsGetNativeDisplayType();
m_NPT = 0;//(EGLNativePixmapType) OsGetNativePixmapType();
m_NWT = (EGLNativeWindowType)(sii.nativeWindowPTR);//(EGLNativeWindowType) OsGetNativeWindowType();
m_EGLContext = 0;
do
{
bDone = true;
m_EGLDisplay = eglGetDisplay(m_NDT);
if(m_EGLDisplay == EGL_NO_DISPLAY)
{
#if defined(BUILD_OGLES2) || defined(BUILD_OVG) || defined(BUILD_OGLES3)
m_EGLDisplay = eglGetDisplay((EGLNativeDisplayType)EGL_DEFAULT_DISPLAY);
#else
m_EGLDisplay = eglGetDisplay((NativeDisplayType)EGL_DEFAULT_DISPLAY);
#endif
}
if(!eglInitialize(m_EGLDisplay, &m_MajorVersion, &m_MinorVersion))
{
gkLogError(_T("RendererGLES2::eglInitialize failed."));
return 0;
}
gkLogMessage(_T("RendererGLES2::eglInitialize success."));
// Check Extension avaliablility after EGL initialization
if (m_MajorVersion > 1 || (m_MajorVersion == 1 && m_MinorVersion >= 1))
{
m_bPowerManagementSupported = true;
}
else
{
m_bPowerManagementSupported = false;
}
do
{
{
//#if defined EGL_VERSION_1_3 && defined GL_ES_VERSION_2_0
if(!eglBindAPI(EGL_OPENGL_ES_API))
{
gkLogError(_T("RendererGLES2::Failed to bind OpenGL ES API\n"));
return 0;
}
//#endif
}
gkLogMessage(_T("RendererGLES2::eglBindAPI success."));
// Find an EGL config
m_EGLConfig = SelectEGLConfiguration();
eglGetConfigAttrib(m_EGLDisplay, m_EGLConfig, EGL_CONFIG_ID, &m_iConfig);
// Destroy the context if we already created one
if (m_EGLContext)
{
eglDestroyContext(m_EGLDisplay, m_EGLContext);
}
// Attempt to create a context
EGLint ai32ContextAttribs[32];
int i = 0;
//#if defined(EGL_VERSION_1_3) && defined(GL_ES_VERSION_2_0)
ai32ContextAttribs[i++] = EGL_CONTEXT_CLIENT_VERSION;
ai32ContextAttribs[i++] = 2;
//#endif
// #if defined(BUILD_OGLES2) || defined(BUILD_OGLES) || defined(BUILD_OGLES3)
// if(PVRShellIsExtensionSupported(m_EGLDisplay,"EGL_IMG_context_priority"))
// {
// ai32ContextAttribs[i++] = EGL_CONTEXT_PRIORITY_LEVEL_IMG;
// switch(m_pShell->PVRShellGet(prefPriority))
// {
// case 0: ai32ContextAttribs[i++] = EGL_CONTEXT_PRIORITY_LOW_IMG; break;
// case 1: ai32ContextAttribs[i++] = EGL_CONTEXT_PRIORITY_MEDIUM_IMG; break;
// default:ai32ContextAttribs[i++] = EGL_CONTEXT_PRIORITY_HIGH_IMG;
// }
// }
// #endif
ai32ContextAttribs[i] = EGL_NONE;
m_EGLContext = eglCreateContext(m_EGLDisplay, m_EGLConfig, NULL, ai32ContextAttribs);
if(m_EGLContext == EGL_NO_CONTEXT)
{
if(m_iRequestedConfig > 0)
{
// We failed to create a context
gkLogError(_T("RendererGLES2::eglCreateContext failed."));
return 0;
}
}
gkLogMessage(_T("RendererGLES2::eglCreateContext retry."));
} while(m_EGLContext == EGL_NO_CONTEXT);
EGLint attrib_list[16];
int i = 0;
// #if defined(EGL_VERSION_1_2)
// if(m_pShell->m_pShellData->bNeedAlphaFormatPre) // The default is EGL_ALPHA_FORMAT_NONPRE
// {
// attrib_list[i++] = EGL_ALPHA_FORMAT;
// attrib_list[i++] = EGL_ALPHA_FORMAT_PRE;
// }
// #endif
// Terminate the attribute list with EGL_NONE
attrib_list[i] = EGL_NONE;
// if(m_pShell->m_pShellData->bNeedPixmap)
// {
// m_pShell->PVRShellOutputDebug("InitAPI() Using pixmaps, about to create egl surface\n");
// m_EGLWindow = eglCreatePixmapSurface(m_EGLDisplay, m_EGLConfig, m_NPT, attrib_list);
// }
// else
{
//#if defined(ANDROID)
EGLint visualID;
eglGetConfigAttrib(m_EGLDisplay, m_EGLConfig, EGL_NATIVE_VISUAL_ID, &visualID);
gkLogMessage(_T("RendererGLES2::eglGetConfigAttrib success."));
// Change the format of our window to match our config
ANativeWindow_setBuffersGeometry(m_NWT, 0, 0, visualID);
gkLogMessage(_T("RendererGLES2::ANativeWindow_setBuffersGeometry success."));
//#endif
m_EGLWindow = eglCreateWindowSurface(m_EGLDisplay, m_EGLConfig, m_NWT, attrib_list);
// If we have failed to create a surface then try using Null
if(m_EGLWindow == EGL_NO_SURFACE)
{
m_EGLWindow = eglCreateWindowSurface(m_EGLDisplay, m_EGLConfig, NULL, attrib_list);
}
}
if (m_EGLWindow == EGL_NO_SURFACE)
{
gkLogError(_T("RendererGLES2::eglCreateWindowSurface failed."));
return false;
}
if (!eglMakeCurrent(m_EGLDisplay, m_EGLWindow, m_EGLWindow, m_EGLContext))
{
#ifdef EGL_VERSION_1_3
if((eglGetError() == EGL_CONTEXT_LOST))
#else
if((eglGetError() == EGL_CONTEXT_LOST_IMG) && m_bPowerManagementSupported)
#endif
{
bDone = false;
}
else
{
gkLogError(_T("RendererGLES2::eglMakeCurrent failed."));
return false;
}
}
} while(!bDone);
/*
Get correct screen width and height and
save them into
m_pShell->m_pShellData->nShellDimX and
m_pShell->m_pShellData->nShellDimY
*/
EGLint screenWidth;
EGLint screenHeight;
eglQuerySurface(m_EGLDisplay, m_EGLWindow, EGL_WIDTH, &screenWidth);
eglQuerySurface(m_EGLDisplay, m_EGLWindow, EGL_HEIGHT, &screenHeight);
getRenderer()->SetCurrContent(0,0,0,screenWidth, screenHeight);
glViewport(0,0,screenWidth, screenHeight);
gkLogMessage(_T("RendererGLES2::CreateDevice Success! %d x %d"), screenWidth, screenHeight);
eglSwapInterval(m_EGLDisplay, 0);
sii.fWidth = screenWidth;
sii.fHeight = screenHeight;
/*
Done - activate requested features
*/
//ApiActivatePreferences();
//glViewport(0,0,sii.fWidth, sii.fHeight);
return (HWND)1;
}
static int angle_init(struct MPGLContext *ctx, int flags)
{
struct priv *p = ctx->priv;
struct vo *vo = ctx->vo;
if (!angle_load()) {
MP_VERBOSE(vo, "Failed to load LIBEGL.DLL\n");
goto fail;
}
if (!vo_w32_init(vo))
goto fail;
HDC dc = GetDC(vo_w32_hwnd(vo));
if (!dc) {
MP_FATAL(vo, "Couldn't get DC\n");
goto fail;
}
PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT =
(PFNEGLGETPLATFORMDISPLAYEXTPROC)eglGetProcAddress("eglGetPlatformDisplayEXT");
if (!eglGetPlatformDisplayEXT) {
MP_FATAL(vo, "Missing EGL_EXT_platform_base\n");
goto fail;
}
EGLint d3d_types[] = {EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE,
EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE,
EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE};
EGLint d3d_dev_types[] = {EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE,
EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE,
EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE};
for (int i = 0; i < MP_ARRAY_SIZE(d3d_types); i++) {
EGLint display_attributes[] = {
EGL_PLATFORM_ANGLE_TYPE_ANGLE,
d3d_types[i],
EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE,
d3d_dev_types[i],
EGL_NONE,
};
p->egl_display = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, dc,
display_attributes);
if (p->egl_display == EGL_NO_DISPLAY)
continue;
if (!eglInitialize(p->egl_display, NULL, NULL)) {
p->egl_display = EGL_NO_DISPLAY;
continue;
}
if (d3d_dev_types[i] == EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE)
show_sw_adapter_msg(ctx);
break;
}
if (p->egl_display == EGL_NO_DISPLAY) {
MP_FATAL(vo, "Couldn't get display\n");
goto fail;
}
const char *exts = eglQueryString(p->egl_display, EGL_EXTENSIONS);
if (exts)
MP_DBG(ctx->vo, "EGL extensions: %s\n", exts);
eglBindAPI(EGL_OPENGL_ES_API);
if (eglGetError() != EGL_SUCCESS) {
MP_FATAL(vo, "Couldn't bind GLES API\n");
goto fail;
}
EGLConfig config = select_fb_config_egl(ctx);
if (!config)
goto fail;
int window_attribs_len = 0;
EGLint *window_attribs = NULL;
EGLint flip_val;
if (eglGetConfigAttrib(p->egl_display, config,
EGL_OPTIMAL_SURFACE_ORIENTATION_ANGLE, &flip_val))
{
if (flip_val == EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE) {
MP_TARRAY_APPEND(NULL, window_attribs, window_attribs_len,
EGL_SURFACE_ORIENTATION_ANGLE);
MP_TARRAY_APPEND(NULL, window_attribs, window_attribs_len,
EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE);
ctx->flip_v = true;
MP_VERBOSE(vo, "Rendering flipped.\n");
}
}
// EGL_DIRECT_COMPOSITION_ANGLE enables the use of flip-mode present, which
// avoids a copy of the video image and lowers vsync jitter, though the
// extension is only present on Windows 8 and up, and might have subpar
// behavior with some drivers (Intel? symptom - whole desktop is black for
// some seconds after spending some minutes in fullscreen and then leaving
// fullscreen).
if ((flags & VOFLAG_ANGLE_DCOMP) &&
strstr(exts, "EGL_ANGLE_direct_composition"))
{
MP_TARRAY_APPEND(NULL, window_attribs, window_attribs_len,
EGL_DIRECT_COMPOSITION_ANGLE);
MP_TARRAY_APPEND(NULL, window_attribs, window_attribs_len, EGL_TRUE);
MP_VERBOSE(vo, "Using DirectComposition.\n");
}
MP_TARRAY_APPEND(NULL, window_attribs, window_attribs_len, EGL_NONE);
p->egl_surface = eglCreateWindowSurface(p->egl_display, config,
vo_w32_hwnd(vo), window_attribs);
talloc_free(window_attribs);
if (p->egl_surface == EGL_NO_SURFACE) {
MP_FATAL(ctx->vo, "Could not create EGL surface!\n");
goto fail;
}
if (!(!p->use_es2 && create_context_egl(ctx, config, 3)) &&
!create_context_egl(ctx, config, 2))
{
MP_FATAL(ctx->vo, "Could not create EGL context!\n");
goto fail;
}
// Configure the underlying Direct3D device
d3d_init(ctx);
if (strstr(exts, "EGL_NV_post_sub_buffer")) {
p->eglPostSubBufferNV =
(PFNEGLPOSTSUBBUFFERNVPROC)eglGetProcAddress("eglPostSubBufferNV");
}
mpgl_load_functions(ctx->gl, get_proc_address, NULL, vo->log);
return 0;
fail:
angle_uninit(ctx);
return -1;
}
void QEGLPlatformContext::init(const QSurfaceFormat &format, QPlatformOpenGLContext *share)
{
m_format = q_glFormatFromConfig(m_eglDisplay, m_eglConfig);
// m_format now has the renderableType() resolved (it cannot be Default anymore)
// but does not yet contain version, profile, options.
m_shareContext = share ? static_cast<QEGLPlatformContext *>(share)->m_eglContext : 0;
QVector<EGLint> contextAttrs;
contextAttrs.append(EGL_CONTEXT_CLIENT_VERSION);
contextAttrs.append(format.majorVersion());
const bool hasKHRCreateContext = q_hasEglExtension(m_eglDisplay, "EGL_KHR_create_context");
if (hasKHRCreateContext) {
contextAttrs.append(EGL_CONTEXT_MINOR_VERSION_KHR);
contextAttrs.append(format.minorVersion());
int flags = 0;
// The debug bit is supported both for OpenGL and OpenGL ES.
if (format.testOption(QSurfaceFormat::DebugContext))
flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
// The fwdcompat bit is only for OpenGL 3.0+.
if (m_format.renderableType() == QSurfaceFormat::OpenGL
&& format.majorVersion() >= 3
&& !format.testOption(QSurfaceFormat::DeprecatedFunctions))
flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
if (flags) {
contextAttrs.append(EGL_CONTEXT_FLAGS_KHR);
contextAttrs.append(flags);
}
// Profiles are OpenGL only and mandatory in 3.2+. The value is silently ignored for < 3.2.
if (m_format.renderableType() == QSurfaceFormat::OpenGL) {
contextAttrs.append(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR);
contextAttrs.append(format.profile() == QSurfaceFormat::CoreProfile
? EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
: EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR);
}
}
contextAttrs.append(EGL_NONE);
switch (m_format.renderableType()) {
case QSurfaceFormat::OpenVG:
m_api = EGL_OPENVG_API;
break;
#ifdef EGL_VERSION_1_4
case QSurfaceFormat::OpenGL:
m_api = EGL_OPENGL_API;
break;
#endif // EGL_VERSION_1_4
default:
m_api = EGL_OPENGL_ES_API;
break;
}
eglBindAPI(m_api);
m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, m_shareContext, contextAttrs.constData());
if (m_eglContext == EGL_NO_CONTEXT && m_shareContext != EGL_NO_CONTEXT) {
m_shareContext = 0;
m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, 0, contextAttrs.constData());
}
if (m_eglContext == EGL_NO_CONTEXT) {
qWarning("QEGLPlatformContext: Failed to create context: %x", eglGetError());
return;
}
static const bool printConfig = qEnvironmentVariableIntValue("QT_QPA_EGLFS_DEBUG");
if (printConfig) {
qDebug() << "Created context for format" << format << "with config:";
q_printEglConfig(m_eglDisplay, m_eglConfig);
}
// Cannot just call updateFormatFromGL() since it relies on virtuals. Defer it to initialize().
}
static EGLDisplay sharedEGLDisplay()
{
static bool initialized = false;
if (!initialized) {
initialized = true;
#if PLATFORM(X11)
gSharedEGLDisplay = eglGetDisplay(GLContext::sharedX11Display());
#else
gSharedEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
#endif
if (gSharedEGLDisplay != EGL_NO_DISPLAY && (!eglInitialize(gSharedEGLDisplay, 0, 0) || !eglBindAPI(gGLAPI)))
gSharedEGLDisplay = EGL_NO_DISPLAY;
}
return gSharedEGLDisplay;
}
void (*QEGLPlatformContext::getProcAddress(const QByteArray &procName)) ()
{
eglBindAPI(m_api);
return eglGetProcAddress(procName.constData());
}
int main(int argc, char **argv)
{
EGLint attribs[] = {
EGL_CONTEXT_MAJOR_VERSION_KHR, 2,
EGL_NONE
};
const char *version_string;
int major;
int minor;
if (!EGL_KHR_create_context_setup(EGL_OPENGL_BIT)) {
fprintf(stderr, "Desktop GL not available.\n");
piglit_report_result(PIGLIT_SKIP);
}
eglBindAPI(EGL_OPENGL_API);
/* The EGL_KHR_create_context spec says:
*
* "Typically, the implementation will return the most recent
* version of OpenGL it supports which is backwards compatible
* with the requested version."
*
* "The default values for EGL_CONTEXT_MAJOR_VERSION_KHR and
* EGL_CONTEXT_MINOR_VERSION_KHR are 1 and 0 respectively."
*
* Request an OpenGL 2.0 context by explicitly setting the major
* version to 2 and leaving the major version at the default value of
* 0. The Linux OpenGL ABI only requires OpenGL 1.2, so this might
* fail to create a context.
*/
ctx = eglCreateContext(egl_dpy, cfg, EGL_NO_CONTEXT, attribs);
if (ctx == EGL_NO_CONTEXT) {
fprintf(stderr, "eglCreateContext() failed with "
"EGL_CONTEXT_MAJOR_VERSION_KHR=%d. skipping "
"test.\n", attribs[1]);
piglit_report_result(PIGLIT_SKIP);
}
if (!eglMakeCurrent(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx)) {
fprintf(stderr, "eglMakeCurrent() failed\n");
piglit_report_result(PIGLIT_FAIL);
}
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
version_string = (char *) glGetString(GL_VERSION);
if (!parse_version_string(version_string, &major, &minor)) {
fprintf(stderr,
"Unable to parse GL version string: %s\n",
version_string);
piglit_report_result(PIGLIT_FAIL);
}
if ((major == 2 && (minor < 0 || minor > 1)) ||
(major == 3 && (minor != 0)) ||
(major < 2 || major > 3)) {
fprintf(stderr,
"Unexpected GL version: %s\n"
"Expected GL 2.0, 2.1, or 3.0.\n",
version_string);
piglit_report_result(PIGLIT_FAIL);
}
eglMakeCurrent(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(egl_dpy, ctx);
EGL_KHR_create_context_teardown();
piglit_report_result(PIGLIT_PASS);
return EXIT_SUCCESS;
}
void process_vg_info(writer &p_vg_writer, egl_scope const &p_egl_scope)
{
EGLint attribs[] =
{
EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
EGL_NONE
};
EGLint num_configs;
EGLConfig config;
if (!eglChooseConfig(p_egl_scope.get_display(), attribs, &config, 1, &num_configs) || (num_configs < 1))
{
PRINT_EGL_ERROR("Could not find config for OpenVG (perhaps this API is unsupported?)");
return;
}
EGLint vid;
if (!eglGetConfigAttrib(p_egl_scope.get_display(), config, EGL_NATIVE_VISUAL_ID, &vid))
{
PRINT_EGL_ERROR("Could not get native visual ID from chosen config");
return;
}
native_window window(p_egl_scope.get_native_display(), vid);
eglBindAPI(EGL_OPENVG_API);
scoped_context context(p_egl_scope.get_display(), eglCreateContext(p_egl_scope.get_display(), config, EGL_NO_CONTEXT, NULL));
scoped_surface surface(p_egl_scope.get_display(), eglCreateWindowSurface(p_egl_scope.get_display(), config, window.get_egl_native_window(), NULL));
if (!eglMakeCurrent(p_egl_scope.get_display(), surface.get_surface(), surface.get_surface(), context.get_context()))
{
PRINT_EGL_ERROR("eglMakeCurrent() failed");
return;
}
p_vg_writer.write_main_vg_info(
reinterpret_cast < char const * > (vgGetString(VG_VENDOR))
, reinterpret_cast < char const * > (vgGetString(VG_VERSION))
, reinterpret_cast < char const * > (vgGetString(VG_RENDERER))
, reinterpret_cast < char const * > (vgGetString(VG_EXTENSIONS))
);
openvg_stats stats;
stats.m_max_scissor_rects = vgGeti(VG_MAX_SCISSOR_RECTS);
stats.m_max_dash_count = vgGeti(VG_MAX_DASH_COUNT);
stats.m_max_kernel_size = vgGeti(VG_MAX_KERNEL_SIZE);
stats.m_max_separable_kernel_size = vgGeti(VG_MAX_SEPARABLE_KERNEL_SIZE);
stats.m_max_color_ramp_stops = vgGeti(VG_MAX_COLOR_RAMP_STOPS);
stats.m_max_image_width = vgGeti(VG_MAX_IMAGE_WIDTH);
stats.m_max_image_height = vgGeti(VG_MAX_IMAGE_HEIGHT);
stats.m_max_image_pixels = vgGeti(VG_MAX_IMAGE_PIXELS);
stats.m_max_image_bytes = vgGeti(VG_MAX_IMAGE_BYTES);
stats.m_max_gaussian_std_deviation = vgGeti(VG_MAX_GAUSSIAN_STD_DEVIATION);
p_vg_writer.write_vg_stats(stats);
p_vg_writer.begin_write_vg_image_format_acceleration();
for (image_format_accel_entry const *accel_entry = image_format_accel_table; accel_entry->m_name != NULL; ++accel_entry)
{
VGHardwareQueryResult acceleration = vgHardwareQuery(VG_IMAGE_FORMAT_QUERY, accel_entry->m_format);
p_vg_writer.write_vg_image_format_acceleration(accel_entry->m_format, accel_entry->m_name, (acceleration == VG_HARDWARE_ACCELERATED));
}
p_vg_writer.end_write_vg_image_format_acceleration();
p_vg_writer.write_vg_path_datatype_acceleration(
get_path_datatype_acceleration(VG_PATH_DATATYPE_S_8)
, get_path_datatype_acceleration(VG_PATH_DATATYPE_S_16)
, get_path_datatype_acceleration(VG_PATH_DATATYPE_S_32)
, get_path_datatype_acceleration(VG_PATH_DATATYPE_F)
);
eglMakeCurrent(p_egl_scope.get_display(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}
bool WindowlessWindowsEglApplication::tryCreateContext(const Configuration&) {
CORRADE_ASSERT(!_context, "Platform::WindowlessWindowsEglApplication::tryCreateContext(): context already created", false);
/* Initialize */
_display = eglGetDisplay(GetDC(_window));
if(!eglInitialize(_display, nullptr, nullptr)) {
Error() << "Platform::WindowlessWindowsEglApplication::tryCreateContext(): cannot initialize EGL:" << Implementation::eglErrorString(eglGetError());
return false;
}
const EGLenum api =
#ifndef MAGNUM_TARGET_GLES
EGL_OPENGL_API
#else
EGL_OPENGL_ES_API
#endif
;
if(!eglBindAPI(api)) {
Error() << "Platform::WindowlessWindowsEglApplication::tryCreateContext(): cannot bind EGL API:" << Implementation::eglErrorString(eglGetError());
return false;
}
/* Choose EGL config */
static const EGLint attribs[] = {
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
EGL_DEPTH_SIZE, 1,
#ifndef MAGNUM_TARGET_GLES
EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
#elif defined(MAGNUM_TARGET_GLES3)
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT,
#elif defined(MAGNUM_TARGET_GLES2)
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
#else
#error unsupported OpenGL edition
#endif
EGL_NONE
};
EGLint configCount;
if(!eglChooseConfig(_display, attribs, &_config, 1, &configCount)) {
Error() << "Platform::WindowlessWindowsEglApplication::tryCreateContext(): cannot get EGL visual config:" << Implementation::eglErrorString(eglGetError());
return false;
}
if(!configCount) {
Error() << "Platform::WindowlessWindowsEglApplication::tryCreateContext(): no matching EGL visual config available";
return false;
}
static const EGLint attributes[] = {
#ifdef MAGNUM_TARGET_GLES
EGL_CONTEXT_CLIENT_VERSION,
#ifdef MAGNUM_TARGET_GLES3
3,
#elif defined(MAGNUM_TARGET_GLES2)
2,
#else
#error unsupported OpenGL ES version
#endif
#endif
EGL_NONE
};
if(!(_glContext = eglCreateContext(_display, _config, EGL_NO_CONTEXT, attributes))) {
Error() << "Platform::WindowlessWindowsEglApplication::tryCreateContext(): cannot create EGL context:" << Implementation::eglErrorString(eglGetError());
return false;
}
if(!(_surface = eglCreateWindowSurface(_display, _config, _window, nullptr))) {
Error() << "Platform::WindowlessWindowsEglApplication::tryCreateContext(): cannot create window surface:" << Implementation::eglErrorString(eglGetError());
return false;
}
if(!eglMakeCurrent(_display, _surface, _surface, _glContext)) {
Error() << "Platform::WindowlessWindowsEglApplication::tryCreateContext(): cannot make context current:" << Implementation::eglErrorString(eglGetError());
return false;
}
_context.reset(new Platform::Context);
return true;
}
void init(android_app *app)
{
user_data *p = (user_data *)app->userData;
p->display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(p->display, 0, 0);
int attrib_list[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
EGLConfig config;
int num_config;
eglChooseConfig(p->display, attrib_list, &config, 1, &num_config);
int format;
eglGetConfigAttrib(p->display, config, EGL_NATIVE_VISUAL_ID, &format);
ANativeWindow_setBuffersGeometry(app->window, 0, 0, format);
p->surface = eglCreateWindowSurface(p->display, config, app->window, 0);
const int context_attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
eglBindAPI(EGL_OPENGL_ES_API);
p->context = eglCreateContext(p->display, config, EGL_NO_CONTEXT, context_attribs);
eglMakeCurrent(p->display, p->surface, p->surface, p->context);
p->program = glCreateProgram();
char *vertex_shader_source =
"attribute vec2 a_pos; \n"
"attribute vec2 a_tex_coord; \n"
"varying vec2 v_tex_coord; \n"
"void main() \n"
"{ \n"
" gl_Position = vec4(a_pos, 0, 1); \n"
" v_tex_coord = a_tex_coord; \n"
"} \n";
char *fragment_shader_source =
"precision mediump float;\n"
"varying vec2 v_tex_coord;\n"
"uniform sampler2D tex;\n"
"void main() \n"
"{ \n"
" vec4 texture_color = vec4(texture2D( tex, v_tex_coord ).bgr, 1.0);\n"
" gl_FragColor = texture_color;\n"
"} \n";
uint vertex_shader_id;
uint fragment_shader_id;
{
uint shader = vertex_shader_id = glCreateShader(GL_VERTEX_SHADER);
int compiled;
glShaderSource(shader, 1, (const char* const *)&vertex_shader_source, 0);
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
char info_log[1024];
glGetShaderInfoLog(shader, sizeof(info_log), 0, info_log);
__android_log_print(ANDROID_LOG_INFO, p->app_name, "vertex shader failed to compile: %s", info_log);
}
}
{
uint shader = fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER);
int compiled;
glShaderSource(shader, 1, (const char* const *)&fragment_shader_source, 0);
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
char info_log[1024];
glGetShaderInfoLog(shader, sizeof(info_log), 0, info_log);
__android_log_print(ANDROID_LOG_INFO, p->app_name, "fragment shader failed to compile: %s", info_log);
}
}
glAttachShader(p->program, vertex_shader_id);
glAttachShader(p->program, fragment_shader_id);
glLinkProgram(p->program);
int linked;
glGetProgramiv(p->program, GL_LINK_STATUS, &linked);
if (!linked)
{
char info_log[1024];
glGetProgramInfoLog(p->program, sizeof(info_log), 0, info_log);
__android_log_print(ANDROID_LOG_INFO, p->app_name, "program failed to link: %s", info_log);
}
glUseProgram(p->program);
p->a_pos_id = glGetAttribLocation(p->program, "a_pos");
p->a_tex_coord_id = glGetAttribLocation(p->program, "a_tex_coord");
p->sampler_id = glGetAttribLocation(p->program, "tex");
glEnableVertexAttribArray(p->a_pos_id);
glEnableVertexAttribArray(p->a_tex_coord_id);
glGenTextures(1, &p->texture_id);
glBindTexture(GL_TEXTURE_2D, p->texture_id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
960, 540, 0,
GL_RGBA, GL_UNSIGNED_BYTE, p->texture_buffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glDepthFunc(GL_ALWAYS);
glDisable(GL_DEPTH_TEST);
glDisable(GL_STENCIL_TEST);
glDisable(GL_CULL_FACE);
p->drawable = 1;
}
gboolean gst_imx_egl_viv_sink_egl_platform_init_window(GstImxEglVivSinkEGLPlatform *platform, guintptr window_handle, gboolean event_handling, GstVideoInfo *video_info, gboolean fullscreen, gint x_coord, gint y_coord, guint width, guint height, gboolean borderless)
{
EGLint num_configs;
EGLConfig config;
Window x11_window;
Display *x11_display = (Display *)(platform->native_display);
static EGLint const eglconfig_attribs[] =
{
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
static EGLint const ctx_attribs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
if (!eglChooseConfig(platform->egl_display, eglconfig_attribs, &config, 1, &num_configs))
{
GST_ERROR("eglChooseConfig failed: %s", gst_imx_egl_viv_sink_egl_platform_get_last_error_string());
return FALSE;
}
EGL_PLATFORM_LOCK(platform);
{
EGLint native_visual_id;
XVisualInfo visual_info_template;
XVisualInfo *visual_info;
int num_matching_visuals;
XSetWindowAttributes attr;
int screen_num;
Window root_window;
Atom net_wm_state_atom, net_wm_state_fullscreen_atom;
guint chosen_width, chosen_height;
GST_INFO("Creating new X11 window with EGL context (parent window: %" G_GUINTPTR_FORMAT ")", window_handle);
if (!eglGetConfigAttrib(platform->egl_display, config, EGL_NATIVE_VISUAL_ID, &native_visual_id))
{
GST_ERROR("eglGetConfigAttrib failed: %s", gst_imx_egl_viv_sink_egl_platform_get_last_error_string());
EGL_PLATFORM_UNLOCK(platform);
return FALSE;
}
screen_num = DefaultScreen(x11_display);
root_window = RootWindow(x11_display, screen_num);
memset(&visual_info_template, 0, sizeof(visual_info_template));
visual_info_template.visualid = native_visual_id;
visual_info = XGetVisualInfo(x11_display, VisualIDMask, &visual_info_template, &num_matching_visuals);
if (visual_info == NULL)
{
GST_ERROR("Could not get visual info for native visual ID %d", native_visual_id);
EGL_PLATFORM_UNLOCK(platform);
return FALSE;
}
memset(&attr, 0, sizeof(attr));
attr.background_pixmap = None;
attr.background_pixel = BlackPixel(x11_display, screen_num);
attr.border_pixmap = CopyFromParent;
attr.border_pixel = BlackPixel(x11_display, screen_num);
attr.backing_store = NotUseful;
attr.override_redirect = borderless ? True : False;
attr.cursor = None;
if (window_handle != 0)
{
platform->parent_window = (Window)window_handle;
/* Out of the parent window events, only the structure
* notifications are of interest here */
XSelectInput(x11_display, platform->parent_window, StructureNotifyMask);
}
// TODO: xlib error handler
platform->fixed_window_width = width;
platform->fixed_window_height = height;
platform->video_width = GST_VIDEO_INFO_WIDTH(video_info);
platform->video_height = GST_VIDEO_INFO_HEIGHT(video_info);
platform->fullscreen = fullscreen;
/* If either no fixed size is set, or fullscreen is requested, use the video frame size
* In the fullscreen case, the size is actually irrelevant, since it will be overwritten
* with the screen size. But passing zero for the width/height values is invalid, the
* video frame size is used. */
chosen_width = ((width == 0) || fullscreen) ? platform->video_width : width;
chosen_height = ((height == 0) || fullscreen) ? platform->video_height : height;
/* This video output window can be embedded into other windows, for example inside
* media player user interfaces. This is done by making the specified window as
* the parent of the video playback window. */
x11_window = XCreateWindow(
x11_display, (window_handle != 0) ? platform->parent_window : root_window,
x_coord,
y_coord,
chosen_width,
chosen_height,
0, visual_info->depth, InputOutput, visual_info->visual,
CWBackPixel | CWColormap | CWBorderPixel | CWBackingStore | CWOverrideRedirect,
&attr
);
platform->native_window = (EGLNativeWindowType)x11_window;
net_wm_state_atom = XInternAtom(x11_display, "_NET_WM_STATE", True);
net_wm_state_fullscreen_atom = XInternAtom(x11_display, "_NET_WM_STATE_FULLSCREEN", True);
platform->wm_delete_atom = XInternAtom(x11_display, "WM_DELETE_WINDOW", True);
XSetWMProtocols(x11_display, x11_window, &(platform->wm_delete_atom), 1);
XStoreName(x11_display, x11_window, "eglvivsink window");
gst_imx_egl_viv_sink_egl_platform_set_event_handling_nolock(platform, event_handling);
XSizeHints sizehints;
sizehints.x = 0;
sizehints.y = 0;
sizehints.width = chosen_width;
sizehints.height = chosen_height;
sizehints.flags = PPosition | PSize;
XSetNormalHints(x11_display, x11_window, &sizehints);
if (fullscreen)
{
XChangeProperty(
x11_display, x11_window,
net_wm_state_atom,
XA_ATOM, 32, PropModeReplace,
(unsigned char*)&net_wm_state_fullscreen_atom, 1
);
}
XClearWindow(x11_display, x11_window);
XMapRaised(x11_display, x11_window);
if (fullscreen)
{
XEvent event;
event.type = ClientMessage;
event.xclient.window = x11_window;
event.xclient.message_type = net_wm_state_atom;
event.xclient.format = 32;
event.xclient.data.l[0] = 1;
event.xclient.data.l[1] = net_wm_state_fullscreen_atom;
event.xclient.data.l[3] = 0l;
XSendEvent(
x11_display,
root_window,
0,
SubstructureNotifyMask,
&event
);
}
XSync(x11_display, False);
}
eglBindAPI(EGL_OPENGL_ES_API);
platform->egl_context = eglCreateContext(platform->egl_display, config, EGL_NO_CONTEXT, ctx_attribs);
if (platform->egl_context == EGL_NO_CONTEXT)
{
GST_ERROR("eglCreateContext failed: %s", gst_imx_egl_viv_sink_egl_platform_get_last_error_string());
EGL_PLATFORM_UNLOCK(platform);
return FALSE;
}
platform->egl_surface = eglCreateWindowSurface(platform->egl_display, config, platform->native_window, NULL);
if (platform->egl_surface == EGL_NO_SURFACE)
{
GST_ERROR("eglCreateWindowSurface failed: %s", gst_imx_egl_viv_sink_egl_platform_get_last_error_string());
EGL_PLATFORM_UNLOCK(platform);
return FALSE;
}
if (!eglMakeCurrent(platform->egl_display, platform->egl_surface, platform->egl_surface, platform->egl_context))
{
GST_ERROR("eglMakeCurrent failed: %s", gst_imx_egl_viv_sink_egl_platform_get_last_error_string());
EGL_PLATFORM_UNLOCK(platform);
return FALSE;
}
{
XWindowAttributes window_attr;
XGetWindowAttributes(x11_display, x11_window, &window_attr);
if (fullscreen || (platform->fixed_window_width != 0) || (platform->fixed_window_height != 0))
{
platform->fixed_window_width = window_attr.width;
platform->fixed_window_height = window_attr.height;
}
if (platform->window_resized_event_cb != NULL)
platform->window_resized_event_cb(platform, window_attr.width, window_attr.height, platform->user_context);
else
glViewport(0, 0, window_attr.width, window_attr.height);
}
EGL_PLATFORM_UNLOCK(platform);
return TRUE;
}
void pi_setvideo_mode(int width, int height)
{
uint32_t display_width, display_height;
uint32_t display_x=0, display_y=0;
float display_ratio,game_ratio;
VC_RECT_T dst_rect;
VC_RECT_T src_rect;
surface_width = width;
surface_height = height;
VideoBuffer=(unsigned short *) calloc(1, width*height*4);
// get an EGL display connection
display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
assert(display != EGL_NO_DISPLAY);
// initialize the EGL display connection
EGLBoolean result = eglInitialize(display, NULL, NULL);
assert(EGL_FALSE != result);
// get an appropriate EGL frame buffer configuration
EGLint num_config;
EGLConfig config;
static const EGLint attribute_list[] =
{
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_NONE
};
result = eglChooseConfig(display, attribute_list, &config, 1, &num_config);
assert(EGL_FALSE != result);
result = eglBindAPI(EGL_OPENGL_ES_API);
assert(EGL_FALSE != result);
// create an EGL rendering context
static const EGLint context_attributes[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attributes);
assert(context != EGL_NO_CONTEXT);
// create an EGL window surface
int32_t success = graphics_get_display_size(0, &display_width, &display_height);
assert(success >= 0);
display_adj_width = display_width - (config_options.option_display_border * 2);
display_adj_height = display_height - (config_options.option_display_border * 2);
if (config_options.display_smooth_stretch)
{
//We use the dispmanx scaler to smooth stretch the display
//so GLES2 doesn't have to handle the performance intensive postprocessing
uint32_t sx, sy;
// Work out the position and size on the display
display_ratio = (float)display_width/(float)display_height;
game_ratio = (float)width/(float)height;
display_x = sx = display_adj_width;
display_y = sy = display_adj_height;
if(config_options.maintain_aspect_ratio || game_ratio < 1) {
if (game_ratio>display_ratio)
sy = (float)display_adj_width/(float)game_ratio;
else
sx = (float)display_adj_height*(float)game_ratio;
}
// Centre bitmap on screen
display_x = (display_x - sx) / 2;
display_y = (display_y - sy) / 2;
vc_dispmanx_rect_set( &dst_rect,
display_x + config_options.option_display_border,
display_y + config_options.option_display_border,
sx, sy);
}
else
vc_dispmanx_rect_set( &dst_rect, config_options.option_display_border,
config_options.option_display_border,
display_adj_width, display_adj_height);
if (config_options.display_smooth_stretch)
vc_dispmanx_rect_set( &src_rect, 0, 0, width << 16, height << 16);
else
vc_dispmanx_rect_set( &src_rect, 0, 0, display_adj_width << 16, display_adj_height << 16);
dispman_display = vc_dispmanx_display_open(0);
dispman_update = vc_dispmanx_update_start(0);
dispman_element = vc_dispmanx_element_add(dispman_update, dispman_display,
10, &dst_rect, 0, &src_rect,
DISPMANX_PROTECTION_NONE, NULL, NULL, DISPMANX_NO_ROTATE);
//Black background surface dimensions
vc_dispmanx_rect_set( &dst_rect, 0, 0, display_width, display_height );
vc_dispmanx_rect_set( &src_rect, 0, 0, 128 << 16, 128 << 16);
//Create a blank background for the whole screen, make sure width is divisible by 32!
uint32_t crap;
resource_bg = vc_dispmanx_resource_create(VC_IMAGE_RGB565, 128, 128, &crap);
dispman_element_bg = vc_dispmanx_element_add( dispman_update, dispman_display,
9, &dst_rect, resource_bg, &src_rect,
DISPMANX_PROTECTION_NONE, 0, 0,
(DISPMANX_TRANSFORM_T) 0 );
nativewindow.element = dispman_element;
if (config_options.display_smooth_stretch) {
nativewindow.width = width;
nativewindow.height = height;
}
else {
nativewindow.width = display_adj_width;
nativewindow.height = display_adj_height;
}
vc_dispmanx_update_submit_sync(dispman_update);
surface = eglCreateWindowSurface(display, config, &nativewindow, NULL);
assert(surface != EGL_NO_SURFACE);
// connect the context to the surface
result = eglMakeCurrent(display, surface, surface, context);
assert(EGL_FALSE != result);
//Smooth stretch the display size for GLES2 is the size of the bitmap
//otherwise let GLES2 upscale (NEAR) to the size of the display
if (config_options.display_smooth_stretch)
gles2_create(width, height, width, height, 16);
else
gles2_create(display_adj_width, display_adj_height, width, height, 16);
}
void eglActivateApi( EGLint api ) {
EGLBoolean r = eglBindAPI( api );
vAssert( r == EGL_TRUE );
}
bool ANGLETest::createEGLContext()
{
PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT = reinterpret_cast<PFNEGLGETPLATFORMDISPLAYEXTPROC>(eglGetProcAddress("eglGetPlatformDisplayEXT"));
if (!eglGetPlatformDisplayEXT)
{
return false;
}
const EGLint displayAttributes[] =
{
EGL_PLATFORM_ANGLE_TYPE_ANGLE, mTestPlatform,
EGL_NONE,
};
mDisplay = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, mNativeDisplay, displayAttributes);
if (mDisplay == EGL_NO_DISPLAY)
{
destroyEGLContext();
return false;
}
EGLint majorVersion, minorVersion;
if (!eglInitialize(mDisplay, &majorVersion, &minorVersion))
{
destroyEGLContext();
return false;
}
eglBindAPI(EGL_OPENGL_ES_API);
if (eglGetError() != EGL_SUCCESS)
{
destroyEGLContext();
return false;
}
const EGLint configAttributes[] =
{
EGL_RED_SIZE, (mRedBits >= 0) ? mRedBits : EGL_DONT_CARE,
EGL_GREEN_SIZE, (mGreenBits >= 0) ? mGreenBits : EGL_DONT_CARE,
EGL_BLUE_SIZE, (mBlueBits >= 0) ? mBlueBits : EGL_DONT_CARE,
EGL_ALPHA_SIZE, (mAlphaBits >= 0) ? mAlphaBits : EGL_DONT_CARE,
EGL_DEPTH_SIZE, (mDepthBits >= 0) ? mDepthBits : EGL_DONT_CARE,
EGL_STENCIL_SIZE, (mStencilBits >= 0) ? mStencilBits : EGL_DONT_CARE,
EGL_SAMPLE_BUFFERS, mMultisample ? 1 : 0,
EGL_NONE
};
EGLint configCount;
if (!eglChooseConfig(mDisplay, configAttributes, &mConfig, 1, &configCount) || (configCount != 1))
{
destroyEGLContext();
return false;
}
eglGetConfigAttrib(mDisplay, mConfig, EGL_RED_SIZE, &mRedBits);
eglGetConfigAttrib(mDisplay, mConfig, EGL_GREEN_SIZE, &mGreenBits);
eglGetConfigAttrib(mDisplay, mConfig, EGL_BLUE_SIZE, &mBlueBits);
eglGetConfigAttrib(mDisplay, mConfig, EGL_ALPHA_SIZE, &mBlueBits);
eglGetConfigAttrib(mDisplay, mConfig, EGL_DEPTH_SIZE, &mDepthBits);
eglGetConfigAttrib(mDisplay, mConfig, EGL_STENCIL_SIZE, &mStencilBits);
EGLint samples;
eglGetConfigAttrib(mDisplay, mConfig, EGL_SAMPLE_BUFFERS, &samples);
mMultisample = (samples != 0);
mSurface = eglCreateWindowSurface(mDisplay, mConfig, mNativeWindow, NULL);
if(mSurface == EGL_NO_SURFACE)
{
eglGetError(); // Clear error
mSurface = eglCreateWindowSurface(mDisplay, mConfig, NULL, NULL);
}
if (eglGetError() != EGL_SUCCESS)
{
destroyEGLContext();
return false;
}
EGLint contextAttibutes[] =
{
EGL_CONTEXT_CLIENT_VERSION, mClientVersion,
EGL_NONE
};
mContext = eglCreateContext(mDisplay, mConfig, NULL, contextAttibutes);
if (eglGetError() != EGL_SUCCESS)
{
destroyEGLContext();
return false;
}
eglMakeCurrent(mDisplay, mSurface, mSurface, mContext);
if (eglGetError() != EGL_SUCCESS)
{
destroyEGLContext();
return false;
}
return true;
}
StWinGlrc::StWinGlrc(EGLDisplay theDisplay,
const bool theDebugCtx,
int8_t theGlDepthSize)
: myDisplay(theDisplay),
myConfig(NULL),
myRC(EGL_NO_CONTEXT) {
if(theDisplay == EGL_NO_DISPLAY) {
return;
}
EGLint aVerMajor = 0; EGLint aVerMinor = 0;
if(eglInitialize(myDisplay, &aVerMajor, &aVerMinor) != EGL_TRUE) {
ST_ERROR_LOG("EGL, FAILED to initialize Display");
return;
}
ST_DEBUG_LOG("EGL info\n"
+ " Version: " + aVerMajor + "." + aVerMinor + " (" + eglQueryString(myDisplay, EGL_VERSION) + ")\n"
+ " Vendor: " + eglQueryString(myDisplay, EGL_VENDOR) + "\n"
+ " Client APIs: " + eglQueryString(myDisplay, EGL_CLIENT_APIS) + "\n"
+ " Extensions: " + eglQueryString(myDisplay, EGL_EXTENSIONS));
const EGLint aConfigAttribs[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 0,
EGL_DEPTH_SIZE, theGlDepthSize,
#if defined(GL_ES_VERSION_2_0)
EGL_CONFORMANT, EGL_OPENGL_ES2_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
#else
EGL_CONFORMANT, EGL_OPENGL_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
#endif
EGL_NONE
};
EGLint aNbConfigs = 0;
if(eglChooseConfig(myDisplay, aConfigAttribs, &myConfig, 1, &aNbConfigs) != EGL_TRUE) {
ST_ERROR_LOG("EGL, eglChooseConfig FAILED");
return;
}
/*EGLenum aEglApi = eglQueryAPI();
switch(aEglApi) {
case EGL_OPENGL_ES_API: ST_DEBUG_LOG("EGL API: OpenGL ES\n"); break;
case EGL_OPENGL_API: ST_DEBUG_LOG("EGL API: OpenGL\n"); break;
case EGL_OPENVG_API: ST_DEBUG_LOG("EGL API: OpenNVG\n"); break;
case EGL_NONE: ST_DEBUG_LOG("EGL API: NONE\n"); break;
}*/
#if defined(GL_ES_VERSION_2_0)
if(eglBindAPI(EGL_OPENGL_ES_API) != EGL_TRUE) {
ST_ERROR_LOG("EGL, EGL_OPENGL_ES_API is unavailable!");
return;
}
#else
if(eglBindAPI(EGL_OPENGL_API) != EGL_TRUE) {
ST_ERROR_LOG("EGL, EGL_OPENGL_API is unavailable!");
return;
}
#endif
#define ST_EGL_CONTEXT_MAJOR_VERSION_KHR 0x3098
#define ST_EGL_CONTEXT_MINOR_VERSION_KHR 0x30FB
#define ST_EGL_CONTEXT_FLAGS_KHR 0x30FC
#define ST_EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30FD
#define ST_EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR 0x31BD
// for EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR
#define ST_EGL_NO_RESET_NOTIFICATION_KHR 0x31BE
#define ST_EGL_LOSE_CONTEXT_ON_RESET_KHR 0x31BF
// for EGL_CONTEXT_FLAGS_KHR
#define ST_EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
#define ST_EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
#define ST_EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR 0x00000004
// for EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR
#define ST_EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
#define ST_EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
const char* anEglExts = eglQueryString(myDisplay, EGL_EXTENSIONS);
if(StGLContext::stglCheckExtension(anEglExts, "EGL_KHR_create_context")) {
const EGLint anEglCtxAttribs[] = {
ST_EGL_CONTEXT_FLAGS_KHR, theDebugCtx ? ST_EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR : 0,
#if defined(GL_ES_VERSION_2_0)
EGL_CONTEXT_CLIENT_VERSION, 2,
#endif
//EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, ST_EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR,
EGL_NONE
};
myRC = eglCreateContext(myDisplay, myConfig, EGL_NO_CONTEXT, anEglCtxAttribs);
}
if(myRC == EGL_NO_CONTEXT) {
#if defined(GL_ES_VERSION_2_0)
EGLint anEglCtxAttribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
#else
EGLint* anEglCtxAttribs = NULL;
#endif
myRC = eglCreateContext(myDisplay, myConfig, EGL_NO_CONTEXT, anEglCtxAttribs);
/*#if defined(GL_ES_VERSION_2_0)
if(myRC == EGL_NO_CONTEXT) {
myRC = eglCreateContext(myDisplay, myConfig, EGL_NO_CONTEXT, NULL);
if(myRC != EGL_NO_CONTEXT) {
ST_ERROR_LOG("EGL, eglCreateContext FAILED when ES 2.0 is requested!");
}
}
#endif*/
}
if(myRC == EGL_NO_CONTEXT) {
ST_ERROR_LOG("EGL, eglCreateContext FAILED");
}
}
/**
* Initialize the default EGL
* Create a Pbuffer Surface for off-screen render
*/
static int initDefaultEGL(SdkEnv *env) {
VALIDATE_NOT_NULL(env);
env->egl.display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (EGL_NO_DISPLAY == env->egl.display ||
EGL_SUCCESS != eglGetError()) {
LogE("Failed eglGetDisplay\n");
return -1;
}
EGLint major, minor;
if (!eglInitialize(env->egl.display, &major, &minor) || EGL_SUCCESS != eglGetError()) {
LogE("Failed eglInitialize\n");
return -1;
}
Log("EGL %d.%d\n", major, minor);
EGLConfig configs[2];
EGLint numConfigs;
if (eglGetConfigs(env->egl.display, configs, 2, &numConfigs) == EGL_FALSE || EGL_SUCCESS != eglGetError()) {
LogE("Failed eglGetConfigs\n");
return -1;
}
EGLint cfg_attrs[] = {
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_NONE
};
if (!eglChooseConfig(env->egl.display, cfg_attrs, configs, 2, &numConfigs) || numConfigs < 1) {
LogE("Failed eglChooseConfig\n");
return -1;
}
#define SURFACE_MAX_WIDTH 2048
#define SURFACE_MAX_HEIGHT 2048
EGLint surface_attrs[] = {
EGL_WIDTH, SURFACE_MAX_WIDTH,
EGL_HEIGHT, SURFACE_MAX_HEIGHT,
/*
EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGAB,
EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
*/
EGL_LARGEST_PBUFFER, EGL_TRUE,
EGL_NONE
};
env->egl.surface = eglCreatePbufferSurface(env->egl.display, configs[0], surface_attrs);
if (EGL_NO_SURFACE == env->egl.surface) {
LogE("Failed create Pbuffer Surface, error code:%x\n", eglGetError());
return -1;
}
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
LogE("Failed eglBindAPI\n");
return -1;
}
EGLint context_attrs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
env->egl.context = eglCreateContext(env->egl.display, configs[0], EGL_NO_CONTEXT, context_attrs);
if (EGL_NO_CONTEXT == env->egl.context) {
LogE("Failed create context, error code:%x\n", eglGetError() );
return -1;
}
if (!eglMakeCurrent(env->egl.display, env->egl.surface, env->egl.surface, env->egl.context)) {
LogE("Failed eglMakeCurrent, error code:%x\n", eglGetError() );
return -1;
}
eglQuerySurface(env->egl.display, env->egl.surface, EGL_WIDTH, &env->egl.width);
eglQuerySurface(env->egl.display, env->egl.surface, EGL_HEIGHT, &env->egl.height);
Log("EGL Pbuffer Surface %d x %d\n", env->egl.width, env->egl.height);
env->type = OFF_SCREEN_RENDER;
return 0;
}
