本文整理汇总了C++中eglBindAPI函数的典型用法代码示例。如果您正苦于以下问题：C++ eglBindAPI函数的具体用法？C++ eglBindAPI怎么用？C++ eglBindAPI使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了eglBindAPI函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: initEGL
/**
* 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;
}示例2: g_print
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));
//.........这里部分代码省略.........
示例3: _glfwCreateContextEGL
// 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);
//.........这里部分代码省略.........
示例4: eglGetDisplay
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;
}
}示例5: InitVideoSdl
//.........这里部分代码省略.........
#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;
}示例6: _glfwCreateContext
// 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)
//.........这里部分代码省略.........
示例7: THEGLInit
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);
}示例8: gfx_ctx_qnx_init
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");
//.........这里部分代码省略.........
示例9: glamor_egl_init
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;
//.........这里部分代码省略.........
示例10: eglGetDisplay
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);
//.........这里部分代码省略.........
示例11: ASSERT
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;
}示例12: initOpenGL
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;
}示例13: init_egl
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");
}示例14: WindowBase
//.........这里部分代码省略.........
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();
}
}
}示例15: OsGetNativePixmapType
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;
}
//.........这里部分代码省略.........