示例#1
0
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
}
示例#2
0
// 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;
}
示例#3
0
    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;
    }
示例#4
0
/**
 * 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;
}
示例#5
0
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;
}
示例#7
0
文件: qegl.cpp 项目: husninazer/qt
// 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;
}
示例#10
0
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;
}
示例#11
0
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;
}
示例#12
0
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;
}
示例#13
0
文件: Egl.cpp 项目: ValXp/particles
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);
}
示例#15
0
     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;
     }
示例#16
0
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;
}
示例#17
0
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;
}
示例#18
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;
}
示例#19
0
文件: main.cpp 项目: lsouchet/gideros
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;
}
示例#20
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;
	}
示例#21
0
  // 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");
    }
  }
示例#22
0
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);
}
示例#23
0
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;
}
示例#24
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;
}
示例#25
0
文件: Editor.cpp 项目: sundoom/glow
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);
}
示例#26
0
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;
}
示例#27
0
文件: EGL.cpp 项目: CCQIU/CGE
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;
}
示例#28
0
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 );
}
示例#30
-2
/// 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;
}