QString QGLInfo::reportEGLConfigInfo() const { #if !defined(QT_NO_EGL) QString d; QEglProperties props; EGLint count = 0; EGLDisplay dpy = eglGetCurrentDisplay(); EGLContext ctx = eglGetCurrentContext(); EGLint cfgnum = 0; if (eglQueryContext(dpy, ctx, EGL_CONFIG_ID, &cfgnum)) { d += QString("Window configuration in use: ") + QString::number(cfgnum) + QLatin1String("\n\n"); } if (!eglGetConfigs(dpy, 0, 0, &count) || count < 1) return d; EGLConfig *configs = new EGLConfig [count]; eglGetConfigs(dpy, configs, count, &count); for (EGLint index = 0; index < count; ++index) { props = QEglProperties(configs[index]); d += props.toString() + QLatin1String("\n\n"); } delete [] configs; return d; #else return QString(); #endif }
// Find an EGLConfig that is an exact match for the specified attributes. EGL_FALSE is returned if // the EGLConfig is found. This indicates that the EGLConfig is not supported. EGLBoolean EGLWindow::FindEGLConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *config) { EGLint numConfigs = 0; eglGetConfigs(dpy, nullptr, 0, &numConfigs); std::vector<EGLConfig> allConfigs(numConfigs); eglGetConfigs(dpy, allConfigs.data(), allConfigs.size(), &numConfigs); for (size_t i = 0; i < allConfigs.size(); i++) { bool matchFound = true; for (const EGLint *curAttrib = attrib_list; curAttrib[0] != EGL_NONE; curAttrib += 2) { EGLint actualValue = EGL_DONT_CARE; eglGetConfigAttrib(dpy, allConfigs[i], curAttrib[0], &actualValue); if (curAttrib[1] != actualValue) { matchFound = false; break; } } if (matchFound) { *config = allConfigs[i]; return EGL_TRUE; } } return EGL_FALSE; }
EGLConfig* EGLSupport::getConfigs(GLint *nElements) { EGLConfig *configs; if (eglGetConfigs(mGLDisplay, NULL, 0, nElements) == EGL_FALSE) { OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Failed to choose config", __FUNCTION__); *nElements = 0; return 0; } EGL_CHECK_ERROR configs = (EGLConfig*) malloc(*nElements * sizeof(EGLConfig)); if (eglGetConfigs(mGLDisplay, configs, *nElements, nElements) == EGL_FALSE) { OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Failed to choose config", __FUNCTION__); *nElements = 0; free(configs); return 0; } EGL_CHECK_ERROR return configs; }
/** * Print table of all available configurations. */ static EGLConfig* PrintConfigs(EGLDisplay d) { EGLConfig *configs; EGLint numConfigs, i; if (eglGetConfigs(d, NULL, 0, &numConfigs) != EGL_TRUE) { printf ("eglGetConfigs -> %x\n", eglGetError()); exit (EXIT_FAILURE); } configs = malloc(sizeof(EGLConfig) *numConfigs); eglGetConfigs(d, configs, numConfigs, &numConfigs); printf("Configurations:\n"); printf(" bf lv d st colorbuffer dp st supported \n"); printf(" id sz l b ro r g b a th cl surfaces \n"); printf("----------------------------------------------\n"); for (i = 0; i < numConfigs; i++) { EGLint id, size, level; EGLint red, green, blue, alpha; EGLint depth, stencil; EGLint surfaces; EGLint doubleBuf = 1, stereo = 0; char surfString[100] = ""; eglGetConfigAttrib(d, configs[i], EGL_CONFIG_ID, &id); eglGetConfigAttrib(d, configs[i], EGL_BUFFER_SIZE, &size); eglGetConfigAttrib(d, configs[i], EGL_LEVEL, &level); eglGetConfigAttrib(d, configs[i], EGL_RED_SIZE, &red); eglGetConfigAttrib(d, configs[i], EGL_GREEN_SIZE, &green); eglGetConfigAttrib(d, configs[i], EGL_BLUE_SIZE, &blue); eglGetConfigAttrib(d, configs[i], EGL_ALPHA_SIZE, &alpha); eglGetConfigAttrib(d, configs[i], EGL_DEPTH_SIZE, &depth); eglGetConfigAttrib(d, configs[i], EGL_STENCIL_SIZE, &stencil); eglGetConfigAttrib(d, configs[i], EGL_SURFACE_TYPE, &surfaces); if (surfaces & EGL_WINDOW_BIT) strcat(surfString, "win,"); if (surfaces & EGL_PBUFFER_BIT) strcat(surfString, "pb,"); if (surfaces & EGL_PIXMAP_BIT) strcat(surfString, "pix,"); if (strlen(surfString) > 0) surfString[strlen(surfString) - 1] = 0; printf("0x%02x %2d %2d %c %c %2d %2d %2d %2d %2d %2d %-12s\n", id, size, level, doubleBuf ? 'y' : '.', stereo ? 'y' : '.', red, green, blue, alpha, depth, stencil, surfString); } // free(configs); return configs; }
static cairo_surface_t * _cairo_boilerplate_egl_create_surface (const char *name, cairo_content_t content, double width, double height, double max_width, double max_height, cairo_boilerplate_mode_t mode, int id, void **closure) { egl_target_closure_t *gltc; cairo_surface_t *surface; int major, minor; EGLConfig *configs; EGLint numConfigs; gltc = xcalloc (1, sizeof (egl_target_closure_t)); *closure = gltc; gltc->dpy = eglGetDisplay (EGL_DEFAULT_DISPLAY); if (! eglInitialize (gltc->dpy, &major, &minor)) { free (gltc); return NULL; } eglGetConfigs (gltc->dpy, NULL, 0, &numConfigs); if (numConfigs == 0) { free (gltc); return NULL; } configs = xmalloc(sizeof(*configs) *numConfigs); eglGetConfigs (gltc->dpy, configs, numConfigs, &numConfigs); eglBindAPI (EGL_OPENGL_API); gltc->ctx = eglCreateContext (gltc->dpy, configs[0], EGL_NO_CONTEXT, NULL); if (gltc->ctx == EGL_NO_CONTEXT) { eglTerminate (gltc->dpy); free (gltc); return NULL; } gltc->device = cairo_egl_device_create (gltc->dpy, gltc->ctx); gltc->surface = surface = cairo_gl_surface_create (gltc->device, content, ceil (width), ceil (height)); if (cairo_surface_status (surface)) _cairo_boilerplate_egl_cleanup (gltc); return surface; }
void QEglProperties::dumpAllConfigs() { EGLint count = 0; eglGetConfigs(QEglContext::defaultDisplay(0), 0, 0, &count); if (count < 1) return; EGLConfig *configs = new EGLConfig [count]; eglGetConfigs(QEglContext::defaultDisplay(0), configs, count, &count); for (EGLint index = 0; index < count; ++index) qWarning() << QEglProperties(configs[index]).toString(); delete [] configs; }
// Dump all of the EGL configurations supported by the system. void QEgl::dumpAllConfigs() { QEglProperties props; EGLint count = 0; if (!eglGetConfigs(display(), 0, 0, &count) || count < 1) return; EGLConfig *configs = new EGLConfig [count]; eglGetConfigs(display(), configs, count, &count); for (EGLint index = 0; index < count; ++index) { props = QEglProperties(configs[index]); qWarning() << props.toString(); } delete [] configs; }
EGLConfig EGLConfigSelector::findMatchingConfigWithVisualId(NativeVisualId id) { if (m_sharedDisplay == EGL_NO_DISPLAY) return 0; EGLint numConfigs; EGLint i; EGLint visualId; EGLConfig config = 0; eglGetConfigs(m_sharedDisplay, 0, 0, &numConfigs); if (!numConfigs) { LOG_ERROR("Failed to retrieve any EGL configs."); return 0; } EGLConfig configs[numConfigs]; eglGetConfigs(m_sharedDisplay, configs, numConfigs, &numConfigs); if (!numConfigs) { LOG_ERROR("Failed to retrieve any EGL configs."); return 0; } int alphaChannelRequired = m_attributes & GLPlatformSurface::SupportAlpha ? 8 : 0; for (i = 0; i < numConfigs; i++) { EGLint alpha, surfaces; EGLConfig tempConfig = configs[i]; eglGetConfigAttrib(m_sharedDisplay, tempConfig, EGL_NATIVE_VISUAL_ID, &visualId); if (static_cast<NativeVisualId>(visualId) != id) continue; eglGetConfigAttrib(m_sharedDisplay, tempConfig, EGL_ALPHA_SIZE, &alpha); if (alphaChannelRequired != alpha) continue; eglGetConfigAttrib(m_sharedDisplay, tempConfig, EGL_SURFACE_TYPE, &surfaces); if (surfaces & EGL_PIXMAP_BIT) { config = tempConfig; break; } } return config; }
static jboolean jni_eglGetConfigs(JNIEnv *_env, jobject _this, jobject display, jobjectArray configs, jint config_size, jintArray num_config) { if (display == NULL || (configs != NULL && _env->GetArrayLength(configs) < config_size) || (num_config != NULL && _env->GetArrayLength(num_config) < 1)) { jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); return JNI_FALSE; } EGLDisplay dpy = getDisplay(_env, display); jboolean success = JNI_FALSE; if (configs == NULL) { config_size = 0; } EGLConfig nativeConfigs[config_size]; int num; success = eglGetConfigs(dpy, configs ? nativeConfigs : 0, config_size, &num); if (num_config != NULL) { _env->SetIntArrayRegion(num_config, 0, 1, (jint*) &num); } if (success && configs) { for (int i=0 ; i<num ; i++) { jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, (jint)nativeConfigs[i]); _env->SetObjectArrayElement(configs, i, obj); } } return success; }
EGLConfig EglConfigForConfigID( const EGLDisplay display, const GLint configID ) { static const int MAX_CONFIGS = 1024; EGLConfig configs[MAX_CONFIGS]; EGLint numConfigs = 0; if ( EGL_FALSE == eglGetConfigs( display, configs, MAX_CONFIGS, &numConfigs ) ) { WARN( "eglGetConfigs() failed" ); return NULL; } for ( int i = 0; i < numConfigs; i++ ) { EGLint value = 0; eglGetConfigAttrib( display, configs[i], EGL_CONFIG_ID, &value ); if ( value == configID ) { return configs[i]; } } return NULL; }
static gboolean make_dummy_surface (ClutterBackendWayland *backend_wayland) { static const EGLint attrs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_RENDERABLE_TYPE, _COGL_RENDERABLE_BIT, EGL_NONE }; EGLint num_configs; eglGetConfigs(backend_wayland->edpy, &backend_wayland->egl_config, 1, &num_configs); if (num_configs < 1) return FALSE; backend_wayland->egl_surface = eglCreatePbufferSurface(backend_wayland->edpy, backend_wayland->egl_config, attrs); if (backend_wayland->egl_surface == EGL_NO_SURFACE) return FALSE; return TRUE; }
static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, EGLint attribute, EGLint wanted, EGLConfig* outConfig) { EGLConfig config = NULL; EGLint numConfigs = -1, n = 0; eglGetConfigs(dpy, NULL, 0, &numConfigs); EGLConfig* const configs = new EGLConfig[numConfigs]; eglChooseConfig(dpy, attrs, configs, numConfigs, &n); if (n) { if (attribute != EGL_NONE) { for (int i=0 ; i<n ; i++) { EGLint value = 0; eglGetConfigAttrib(dpy, configs[i], attribute, &value); if (wanted == value) { *outConfig = configs[i]; delete [] configs; return NO_ERROR; } } } else { // just pick the first one *outConfig = configs[0]; delete [] configs; return NO_ERROR; } } delete [] configs; return NAME_NOT_FOUND; }
void initEglOnly() { const EGLint config_attr[] = { EGL_RED_SIZE, 5, EGL_GREEN_SIZE, 6, EGL_BLUE_SIZE, 5, EGL_ALPHA_SIZE, EGL_DONT_CARE, EGL_NONE }; EGLint configs, major, minor; EGLNativeDisplayType native_disp = fbGetDisplayByIndex(0); /* i.MX6 specific */ fbGetDisplayGeometry(native_disp, &m_width, &m_height); /* i.MX6 specific */ EGLNativeWindowType native_win = fbCreateWindow(native_disp, 0, 0, m_width, m_height); /* i.MX6 specific */ eglBindAPI(EGL_OPENGL_ES_API); m_egldisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); eglInitialize(m_egldisplay, &major, &minor); eglGetConfigs(m_egldisplay, NULL, 0, &configs); eglChooseConfig(m_egldisplay, config_attr, &m_eglconfig, 1, &configs); m_eglsurface = eglCreateWindowSurface(m_egldisplay, m_eglconfig, native_win, NULL); }
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengles_EGL_neglGetConfigs(JNIEnv *env, jclass clazz, jlong dpy_ptr, jlong configs, jint config_size, jlong num_config) { EGLDisplay dpy = (EGLDisplay)(intptr_t)dpy_ptr; EGLConfig *configs_address = (EGLConfig *)(intptr_t)configs; EGLint *num_config_address = (EGLint *)(intptr_t)num_config; return eglGetConfigs(dpy, configs_address, config_size, num_config_address); }
EGLInit( IDirectFB_C *dfb, IDirectFBSurface_C *dfb_surface ) { EGLint width, height; EGLint major, minor, nconfigs; EGLint attribs[] = { EGL_BUFFER_SIZE, EGL_DONT_CARE, EGL_DEPTH_SIZE, 16, EGL_RED_SIZE, 5, EGL_GREEN_SIZE, 6, EGL_RED_SIZE, 5, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_NONE }; EGLint context_attrs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, EGL_NONE }; EGLint surface_attrs[] = { EGL_RENDER_BUFFER, EGL_BACK_BUFFER, EGL_NONE }; EGLint render_buffer = 0; sleep(4); // get display EGL_CHECK((display = eglGetDisplay((EGLNativeDisplayType) dfb)) == EGL_NO_DISPLAY) // init EGL_CHECK(!eglInitialize(display, &major, &minor)) // get configs EGL_CHECK(!eglGetConfigs(display, configs, 2, &nconfigs)) // choose config EGL_CHECK(!eglChooseConfig(display, attribs, configs, 2, &nconfigs)) // create a surface EGL_CHECK((surface = eglCreateWindowSurface(display, configs[0], (EGLNativeWindowType) dfb_surface, surface_attrs)) == EGL_NO_SURFACE) EGL_CHECK(eglBindAPI(EGL_OPENGL_ES_API) != EGL_TRUE) // create context EGL_CHECK((context = eglCreateContext(display, configs[0], EGL_NO_CONTEXT, context_attrs)) == EGL_NO_CONTEXT) EGL_CHECK(eglMakeCurrent(display, surface, surface, context) != EGL_TRUE) eglQuerySurface(display, surface, EGL_WIDTH, &width); eglQuerySurface(display, surface, EGL_HEIGHT, &height); EGL_CHECK(!eglQuerySurface(display, surface, EGL_RENDER_BUFFER, &render_buffer)); // fprintf(stderr,"RENDER_BUFFER = 0x%04x\n", render_buffer ); eglSwapInterval( display, 1 ); quit: return; }
EGLBoolean CreateEGLContext(EGLNativeWindowType hWnd, EGLDisplay* eglDisplay, EGLContext* eglContext, EGLSurface* eglSurface, EGLint* configAttribList, EGLint* surfaceAttribList) { EGLint numConfigs; EGLint majorVersion; EGLint minorVersion; EGLDisplay display; EGLContext context; EGLSurface surface; EGLConfig config; EGLint contextAttribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, EGL_NONE }; // Get display display = eglGetDisplay(GetDC(hWnd)); // EGL_DEFAULT_DISPLAY if (display == EGL_NO_DISPLAY) return EGL_FALSE; // Initialize EGL if (!eglInitialize(display, &majorVersion, &minorVersion)) return EGL_FALSE; // Get configs if (!eglGetConfigs(display, NULL, 0, &numConfigs)) return EGL_FALSE; // Choose config if (!eglChooseConfig(display, configAttribList, &config, 1, &numConfigs)) return EGL_FALSE; // Create a surface surface = eglCreateWindowSurface(display, config, (EGLNativeWindowType)hWnd, surfaceAttribList); if (surface == EGL_NO_SURFACE) return EGL_FALSE; // Bind the API eglBindAPI(EGL_OPENGL_ES_API); // Create a GL context context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs); if (context == EGL_NO_CONTEXT) return EGL_FALSE; // Make the context current if (!eglMakeCurrent(display, surface, surface, context)) return EGL_FALSE; *eglDisplay = display; *eglSurface = surface; *eglContext = context; return EGL_TRUE; }
int main (int argc, char *argv[]) { EGLint config_cc; EGLint cc; EGLConfig config[100]; EGLDisplay edpy = EGL_NO_DISPLAY; griCtlErrorCommit (GRI_ERROR_CRIT_ATTR); /* * * Запрос устройства по-умолчанию * */ edpy = eglGetDisplay (EGL_DEFAULT_DISPLAY); if (edpy == EGL_NO_DISPLAY) griError ("EGL_GET_DISPLAY_FAIL"); /* * * Инициализация устройства * */ if (eglInitialize (edpy, NULL, NULL) == EGL_FALSE) { griError ("EGL_INIT_FAIL"); } /* * * Распечатка версии EGL, поставщика и доступных API * */ printf ("EGL Version: %s\n", eglQueryString (edpy, EGL_VERSION)); printf ("EGL Vendor: %s\n", eglQueryString (edpy, EGL_VENDOR)); printf ("EGL APIs: %s\n", eglQueryString (edpy, EGL_CLIENT_APIS)); /* * * Запрос подходящей конфигурации, подходящей под атрибуты egl_attribs * * EGLDisplay dpy : указатель на интересующее устройство * * EGLConfig *config : указатель на массив возвращаемых конфигов * * EGLint config_size : максимальное количество возможных элементов * * в *config * * EGLint *num_config : количество возвращённых (в *config) конфигураций * */ if (eglGetConfigs (edpy, config, 100, &config_cc) == EGL_FALSE) griError ("EGL_CHOOSE_CONFIG_FAIL"); if (!config_cc) griError ("EGL_NO_CONFIG_AVAILABLE"); cc = config_cc; printf ("# count: %d\n", config_cc); while (cc--) { printf ("# EGLConfig: %d/%d\n", cc, config_cc); print_eglConfig (edpy, config[cc]); } printf ("@ END\n"); return 0; }
/// Query the system for all supported configs int EGLDevice::queryEGLConfig(EGLDisplay display) { GNASH_REPORT_FUNCTION; EGLConfig *configs = 0; EGLint max_num_config = 0; // Get the number of supported configurations if ( EGL_FALSE == eglGetConfigs(display, 0, 0, &max_num_config) ) { log_error("eglGetConfigs() failed to retrive the number of configs (error %s)", getErrorString(eglGetError())); return 0; } if(max_num_config <= 0) { printf( "No EGLconfigs found\n" ); return 0; } log_debug("Max number of EGL Configs is %d", max_num_config); configs = new EGLConfig[max_num_config]; if (0 == configs) { log_error( "Out of memory\n" ); return 0; } if ( EGL_FALSE == eglGetConfigs(display, configs, max_num_config, &max_num_config)) { log_error("eglGetConfigs() failed to retrive the configs (error %s)", getErrorString(eglGetError())); return 0; } #if 0 // This prints out all the configurations, so it can be quite large for (int i=0; i<max_num_config; i++ ) { std::cerr << "Config[" << i << "] is:" << std::endl; printEGLConfig(configs[i]); } #endif return max_num_config; }
int initGL(int width, int height) { //emscripten_set_canvas_size(width,height); #ifndef EGL if (glfwInit() != GL_TRUE) { printf("glfwInit() failed\n"); return GL_FALSE; } if (glfwOpenWindow(width, height, 8, 8, 8, 0, 16, 8, GLFW_WINDOW) != GL_TRUE) { printf("glfwOpenWindow() failed\n"); return GL_FALSE; } /* float ratio=1.0;//emscripten_get_device_pixel_ratio(); EM_ASM_({ var canvas = Module['canvas']; canvas.width=$0; canvas.height=$1; },width*ratio,height*ratio); */ #else EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY); EGLint major = 0, minor = 0; EGLBoolean ret = eglInitialize(display, &major, &minor); EGLint numConfigs; ret = eglGetConfigs(display, NULL, 0, &numConfigs); EGLint attribs[] = { EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_STENCIL_SIZE, 8, EGL_DEPTH_SIZE, 16, EGL_NONE }; EGLConfig config; ret = eglChooseConfig(display, attribs, &config, 1, &numConfigs); EGLNativeWindowType dummyWindow; EGLSurface surface = eglCreateWindowSurface(display, config, dummyWindow, NULL); // WebGL maps to GLES2. GLES1 is not supported. // The correct attributes, should create a good EGL context EGLint contextAttribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; EGLContext context = eglCreateContext(display, config, NULL, contextAttribs); ret = eglMakeCurrent(display, surface, surface, context);*/ #endif return 0; }
bool EglData::create() { if (this->display == NULL) { this->display = eglGetDisplay(EGL_DEFAULT_DISPLAY); if (this->display == EGL_NO_DISPLAY) { hlog::error(logTag, "Can't get EGL Display!"); this->destroy(); return false; } EGLint majorVersion; EGLint minorVersion; if (!eglInitialize(this->display, &majorVersion, &minorVersion)) { hlog::error(logTag, "Can't initialize EGL!"); this->destroy(); return false; } EGLint configs = 0; EGLBoolean result = eglGetConfigs(this->display, NULL, 0, &configs); if (!result || configs == 0) { hlog::error(logTag, "There are no EGL configs!"); this->destroy(); return false; } result = eglChooseConfig(this->display, this->pi32ConfigAttribs, &this->config, 1, &configs); if (!result || configs == 0) { hlog::error(logTag, "Can't choose EGL config!"); this->destroy(); return false; } } if (this->surface == NULL) { this->surface = eglCreateWindowSurface(this->display, this->config, this->hWnd, NULL); } if (this->context == NULL) { this->context = eglCreateContext(this->display, this->config, NULL, NULL); if (!eglMakeCurrent(this->display, this->surface, this->surface, this->context)) { hlog::error(logTag, "Can't set current EGL context!"); this->destroy(); return false; } eglSwapInterval(this->display, 1); } return true; }
// constructor EGLClass(EGLNativeDisplayType id = EGL_DEFAULT_DISPLAY): display(0), surface(0), context(0) { display = eglGetDisplay(id); if (display == EGL_NO_DISPLAY) { LOGE("eglGetDisplay"); } if (!eglInitialize(display, &major, &minor)) { LOGE("eglInitialize: %p", display); } LOGI("EGL: display=%p, major=%d, minor=%d", display, major, minor); // First get number of configurations eglGetConfigs(display, NULL, 0, &config_size); // Allocate configs array configs = new EGLConfig[config_size]; // Get EGL configs if (!eglGetConfigs(display, configs, config_size, &num_config)) { LOGE("eglGetConfigs"); } }
static void init_egl() { EGLint major, minor, count, n, size; EGLConfig *configs; int i; EGLint config_attribs[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_NONE }; static const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; egl_display = eglGetDisplay((EGLNativeDisplayType)display); if (egl_display == EGL_NO_DISPLAY) { fprintf(stderr, "Can't create egl display\n"); exit(1); } else { fprintf(stderr, "Created egl display\n"); } if (eglInitialize(egl_display, &major, &minor) != EGL_TRUE) { fprintf(stderr, "Can't initialise egl display\n"); exit(1); } printf("EGL major: %d, minor %d\n", major, minor); eglGetConfigs(egl_display, NULL, 0, &count); printf("EGL has %d configs\n", count); configs = (EGLConfig *)calloc(count, sizeof * configs); eglChooseConfig(egl_display, config_attribs, configs, count, &n); for (i = 0; i < n; i++) { eglGetConfigAttrib(egl_display, configs[i], EGL_BUFFER_SIZE, &size); printf("Buffer size for config %d is %d\n", i, size); eglGetConfigAttrib(egl_display, configs[i], EGL_RED_SIZE, &size); printf("Red size for config %d is %d\n", i, size); // just choose the first one egl_conf = configs[i]; break; } egl_context = eglCreateContext(egl_display, egl_conf, EGL_NO_CONTEXT, context_attribs); }
int main(int /*argc*/, char** /*argv*/) { EGLConfig* configs; EGLint n; EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); eglInitialize(dpy, 0, 0); eglGetConfigs(dpy, NULL, 0, &n); configs = new EGLConfig[n]; eglGetConfigs(dpy, configs, n, &n); for (EGLint i=0 ; i<n ; i++) { printf("EGLConfig[%d]\n", i); for (unsigned attr = 0 ; attr<sizeof(attributes)/sizeof(Attribute) ; attr++) { EGLint value; eglGetConfigAttrib(dpy, configs[i], attributes[attr].attribute, &value); printf("\t%-32s: %10d (0x%08x)\n", attributes[attr].name, value, value); } } delete [] configs; eglTerminate(dpy); return 0; }
int select_config_for_window(EGLDisplay dpy, EGLint *attr, unsigned format, EGLConfig *config) { EGLint R,G,B,A; EGLint i, n, max; EGLConfig *cfg; switch (format) { case HAL_PIXEL_FORMAT_RGBA_8888: case HAL_PIXEL_FORMAT_BGRA_8888: R = G = B = A = 8; break; case HAL_PIXEL_FORMAT_RGB_565: R = 5; G = 6; B = 5; A = 0; break; default: fprintf(stderr, "unknown fb pixel format %d\n", format); return -1; } if (eglGetConfigs(dpy, NULL, 0, &max) == EGL_FALSE) { fprintf(stderr, "no EGL configurations available?!\n"); return -1; } cfg = (EGLConfig*) malloc(sizeof(EGLConfig) * max); if (!cfg) return -1; if (eglChooseConfig(dpy, attr, cfg, max, &n) == EGL_FALSE) { fprintf(stderr, "eglChooseConfig failed\n"); return -1; } for (i = 0; i < n; i++) { EGLint r,g,b,a; eglGetConfigAttrib(dpy, cfg[i], EGL_RED_SIZE, &r); eglGetConfigAttrib(dpy, cfg[i], EGL_GREEN_SIZE, &g); eglGetConfigAttrib(dpy, cfg[i], EGL_BLUE_SIZE, &b); eglGetConfigAttrib(dpy, cfg[i], EGL_ALPHA_SIZE, &a); if (r == R && g == G && b == B && a == A) { *config = cfg[i]; free(cfg); return 0; } } fprintf(stderr, "cannot find matching config\n"); free(cfg); return -1; }
VOID Editor::Init(HWND hWnd) { CHECK(hWnd); mWnd = hWnd; // Get Display mDisplay = eglGetDisplay(::GetDC(hWnd)); CHECK(mDisplay!=EGL_NO_DISPLAY); // Initialize EGL EGLint major, minor; CHECK(eglInitialize(mDisplay, &major, &minor)); // Get configs EGLint num_configs; CHECK(eglGetConfigs(mDisplay, NULL, 0, &num_configs)); // Choose config EGLint attribs[] = { EGL_RED_SIZE, 5, EGL_GREEN_SIZE, 6, EGL_BLUE_SIZE, 5, EGL_ALPHA_SIZE, EGL_DONT_CARE, EGL_DEPTH_SIZE, EGL_DONT_CARE, EGL_STENCIL_SIZE, EGL_DONT_CARE, EGL_SAMPLE_BUFFERS, 0, EGL_NONE }; EGLConfig config; CHECK(eglChooseConfig(mDisplay, attribs, &config, 1, &num_configs)); // Create a surface mSurface = eglCreateWindowSurface(mDisplay, config, (EGLNativeWindowType)hWnd, NULL); CHECK(mSurface!=EGL_NO_SURFACE); // Create a GL context EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, EGL_NONE }; mContext = eglCreateContext(mDisplay, config, EGL_NO_CONTEXT, context_attribs); CHECK(mContext!=EGL_NO_CONTEXT) // Make the gContext current CHECK(eglMakeCurrent(mDisplay, mSurface, mSurface, mContext)); // init the time Timer::instance().time(); // create the graph context mGraphPtr = GNEW(Graph); CHECK(mGraphPtr); }
int main(int argc, char const** argv) { // Get the default display EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY); printf("display: %p\n", display); assert(display != EGL_NO_DISPLAY); // Initialize EGL and get the versions int major, minor; EGLBoolean result = eglInitialize(display, &major, &minor); assert(result); printf("major: %d, minor: %d\n", major, minor); // Get the configurations available for use. EGLint numConfigsOne; result = eglGetConfigs(display, NULL, 0, &numConfigsOne); assert(result); printf("configs: total %d\n", numConfigsOne); EGLConfig* configs = (EGLConfig*)malloc(sizeof(EGLConfig)*numConfigsOne); EGLint numConfigsTwo; result = eglGetConfigs(display, configs, numConfigsOne, &numConfigsTwo); assert(result); assert(numConfigsOne == numConfigsTwo); EGLint i; for(i = 0; i < numConfigsTwo; ++i) { EGLint bufferSize; eglGetConfigAttrib(display, configs[i], EGL_BUFFER_SIZE, &bufferSize); printf("Config #%d -------------------\n", i); printf("Buffer Size: %d\n", bufferSize); } free(configs); return 0; }
bool_t CC_CALL EGLRenderContext::init(HWND _hWnd, EGLint _attribList[]) { EGLint numConfigs; EGLint majorVersion; EGLint minorVersion; EGLConfig config; EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, EGL_NONE}; /*Get Display*/ eglDisplay = eglGetDisplay(GetDC(_hWnd)); if (eglDisplay == EGL_NO_DISPLAY) { return FALSE; } //Initialize EGL if (!eglInitialize(eglDisplay, &majorVersion, &minorVersion)) { return FALSE; } // Get configs if ( !eglGetConfigs(eglDisplay, NULL, 0, &numConfigs) ) { return EGL_FALSE; } // Choose config if ( !eglChooseConfig(eglDisplay, _attribList, &config, 1, &numConfigs) ) { return EGL_FALSE; } // Create a surface eglSurface = eglCreateWindowSurface(eglDisplay, config, (EGLNativeWindowType)_hWnd, NULL); if ( eglSurface == EGL_NO_SURFACE ) { return EGL_FALSE; } // Create a GL context eglContext = eglCreateContext(eglDisplay, config, EGL_NO_CONTEXT, contextAttribs ); if ( eglContext == EGL_NO_CONTEXT ) { return EGL_FALSE; } // Make the context current if ( !eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext) ) { return EGL_FALSE; } return TRUE; }
void DumpEglConfigs( const EGLDisplay display ) { static const int MAX_CONFIGS = 1024; EGLConfig configs[MAX_CONFIGS]; EGLint numConfigs = 0; if ( EGL_FALSE == eglGetConfigs( display, configs, MAX_CONFIGS, &numConfigs ) ) { WARN( "eglGetConfigs() failed" ); return; } LOG( "ES2 configs:" ); LOG( " Config R G B A DP S M W P REND" ); for ( int i = 0; i < numConfigs; i++ ) { EGLint red = 0; eglGetConfigAttrib( display, configs[i], EGL_RED_SIZE, &red ); EGLint green = 0; eglGetConfigAttrib( display, configs[i], EGL_GREEN_SIZE, &green ); EGLint blue = 0; eglGetConfigAttrib( display, configs[i], EGL_BLUE_SIZE, &blue ); EGLint alpha = 0; eglGetConfigAttrib( display, configs[i], EGL_ALPHA_SIZE, &alpha ); EGLint depth = 0; eglGetConfigAttrib( display, configs[i], EGL_DEPTH_SIZE, &depth ); EGLint stencil = 0; eglGetConfigAttrib( display, configs[i], EGL_STENCIL_SIZE, &stencil ); EGLint multisamples = 0; eglGetConfigAttrib( display, configs[i], EGL_SAMPLES, &multisamples ); // EGL_SURFACE_TYPE is a bit field EGLint surface = 0; eglGetConfigAttrib( display, configs[i], EGL_SURFACE_TYPE , &surface ); EGLint window = (surface & EGL_WINDOW_BIT) != 0; EGLint pbuffer = (surface & EGL_PBUFFER_BIT) != 0; // EGL_RENDERABLE_TYPE is a bit field EGLint renderable = 0; eglGetConfigAttrib( display, configs[i], EGL_RENDERABLE_TYPE , &renderable ); // EGLint window = (surface & EGL_WINDOW_BIT) != 0; // EGLint pbuffer = (surface & EGL_PBUFFER_BIT) != 0; LOG( "%8i %i %i %i %i %2i %i %i %i %i 0x%02x 0x%02x", (int)configs[i], red, green, blue, alpha, depth, stencil, multisamples, window, pbuffer, renderable, surface); } }
void WaylandCore::initEGL() { EGLint major,minor; EGLConfig* configs; EGLint attrib[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8, EGL_DEPTH_SIZE, 16, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_NONE, }; EGLint context_attrib[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, }; mEglDisplay = eglGetDisplay( (EGLNativeDisplayType)mDisplay ); if( mEglDisplay == EGL_NO_DISPLAY ) { fprintf( stderr, "Cannot create egl display.\n" ); } if( eglInitialize(mEglDisplay, &major, &minor ) != EGL_TRUE ) { fprintf( stderr, "Cannot initialize egl display.\n" ); } printf( "EGL major: %d, minor : %d\n", major, minor ); EGLint count = 0; int n = 0; eglGetConfigs( mEglDisplay, NULL, 0, &count ); configs = (EGLConfig*) malloc( count * sizeof(EGLConfig) ); eglChooseConfig( mEglDisplay, attrib, configs, count, &n ); for( int i=0;i<n;++i ) { int size = 0; eglGetConfigAttrib( mEglDisplay, configs[i], EGL_BUFFER_SIZE, &size ); printf( "[%d] Buffer size is %d\n", i, size ); if( size != 32 ) { continue; } eglGetConfigAttrib( mEglDisplay, configs[i], EGL_DEPTH_SIZE, &size ); printf( "[%d] Depth size is %d\n" , i, size ); // とりあえず RGBA8888,デプスありなので最初のものを使用する. mEglConfig = configs[i]; break; } mEglContext = eglCreateContext( mEglDisplay, mEglConfig, EGL_NO_CONTEXT, context_attrib ); }
/// Query the system for all supported configs int GtkOvgGlue::queryEGLConfig(EGLDisplay display) { GNASH_REPORT_FUNCTION; EGLConfig *configs = 0; EGLint max_num_config = 0; // Get the number of supported configurations if ( EGL_FALSE == eglGetConfigs(display, 0, 0, &max_num_config) ) { log_error(_("eglGetConfigs() failed to retrieve the number of configs (error %s)"), getErrorString(eglGetError())); return 0; } if(max_num_config <= 0) { log_error(_("No EGLconfigs found\n")); return 0; } log_debug("Max number of EGL Configs is %d", max_num_config); configs = new EGLConfig[max_num_config]; if (0 == configs) { log_error(_("Out of memory\n")); return 0; } if ( EGL_FALSE == eglGetConfigs(display, configs, max_num_config, &max_num_config)) { log_error(_("eglGetConfigs() failed to retrive the configs (error %s)"), getErrorString(eglGetError())); return 0; } for (int i=0; i<max_num_config; i++ ) { log_debug("Config[%d] is:", i); printEGLConfig(configs[i]); } return max_num_config; }