/* * Class: sun_java2d_opengl_OGLContext * Method: getOGLIdString * Signature: ()Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_sun_java2d_opengl_OGLContext_getOGLIdString (JNIEnv *env, jclass oglcc) { char *vendor, *renderer, *version; char *pAdapterId; jobject ret = NULL; int len; J2dTraceLn(J2D_TRACE_INFO, "OGLContext_getOGLIdString"); vendor = (char*)j2d_glGetString(GL_VENDOR); if (vendor == NULL) { vendor = "Unknown Vendor"; } renderer = (char*)j2d_glGetString(GL_RENDERER); if (renderer == NULL) { renderer = "Unknown Renderer"; } version = (char*)j2d_glGetString(GL_VERSION); if (version == NULL) { version = "unknown version"; } // 'vendor renderer (version)0' len = strlen(vendor) + 1 + strlen(renderer) + 1 + 1+strlen(version)+1 + 1; pAdapterId = malloc(len); if (pAdapterId != NULL) { jio_snprintf(pAdapterId, len, "%s %s (%s)", vendor, renderer, version); J2dTraceLn1(J2D_TRACE_VERBOSE, " id=%s", pAdapterId); ret = JNU_NewStringPlatform(env, pAdapterId); free(pAdapterId); } return ret; }
/** * Determines whether the WGL pipeline can be used for a given GraphicsConfig * provided its screen number and visual ID. If the minimum requirements are * met, the native WGLGraphicsConfigInfo structure is initialized for this * GraphicsConfig with the necessary information (pixel format, etc.) * and a pointer to this structure is returned as a jlong. If * initialization fails at any point, zero is returned, indicating that WGL * cannot be used for this GraphicsConfig (we should fallback on the existing * DX pipeline). */ JNIEXPORT jlong JNICALL Java_sun_java2d_opengl_WGLGraphicsConfig_getWGLConfigInfo(JNIEnv *env, jclass wglgc, jint screennum, jint pixfmt) { OGLContext *oglc; PIXELFORMATDESCRIPTOR pfd; HWND hwnd; HDC hdc; HGLRC context; HPBUFFERARB scratch; HDC scratchDC; WGLGraphicsConfigInfo *wglinfo; const unsigned char *versionstr; const char *extstr; jint caps = CAPS_EMPTY; int attrKeys[] = { WGL_DOUBLE_BUFFER_ARB, WGL_ALPHA_BITS_ARB }; int attrVals[2]; J2dRlsTraceLn(J2D_TRACE_INFO, "WGLGraphicsConfig_getWGLConfigInfo"); // initialize GL/WGL extension functions if (!WGLGC_InitExtFuncs(screennum)) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: could not init ext funcs"); return 0L; } // create a scratch window hwnd = WGLGC_CreateScratchWindow(screennum); if (hwnd == 0) { return 0L; } // get the HDC for the scratch window hdc = GetDC(hwnd); if (hdc == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: could not get dc for scratch window"); DestroyWindow(hwnd); return 0L; } if (pixfmt == 0) { // find an appropriate pixel format pixfmt = WGLGC_GetPixelFormatForDC(hdc); if (pixfmt == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: could not find appropriate pixfmt"); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); return 0L; } } if (sharedContext == 0) { // create the one shared context sharedContext = WGLGC_CreateContext(screennum, pixfmt); if (sharedContext == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: could not create shared context"); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); return 0L; } } // set the pixel format for the scratch window if (!SetPixelFormat(hdc, pixfmt, &pfd)) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsconfig_getWGLConfigInfo: error setting pixel format"); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); return 0L; } // create the HGLRC (context) for this WGLGraphicsConfig context = j2d_wglCreateContext(hdc); if (context == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: could not create WGL context"); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); return 0L; } // REMIND: when using wglShareLists, the two contexts must use an // identical pixel format... if (!j2d_wglShareLists(sharedContext, context)) { J2dRlsTraceLn(J2D_TRACE_WARNING, "WGLGraphicsConfig_getWGLConfigInfo: unable to share lists"); } // make the context current so that we can query the OpenGL version // and extension strings if (!j2d_wglMakeCurrent(hdc, context)) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: could not make temp context current"); j2d_wglDeleteContext(context); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); return 0L; } // get version and extension strings versionstr = j2d_glGetString(GL_VERSION); extstr = j2d_wglGetExtensionsStringARB(hdc); OGLContext_GetExtensionInfo(env, &caps); J2dRlsTraceLn1(J2D_TRACE_INFO, "WGLGraphicsConfig_getWGLConfigInfo: OpenGL version=%s", (versionstr == NULL) ? "null" : (char *)versionstr); if (!OGLContext_IsVersionSupported(versionstr)) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: OpenGL 1.2 is required"); j2d_wglMakeCurrent(NULL, NULL); j2d_wglDeleteContext(context); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); return 0L; } // check for required WGL extensions if (!OGLContext_IsExtensionAvailable(extstr, "WGL_ARB_pbuffer") || !OGLContext_IsExtensionAvailable(extstr, "WGL_ARB_make_current_read")|| !OGLContext_IsExtensionAvailable(extstr, "WGL_ARB_pixel_format")) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: required ext(s) unavailable"); j2d_wglMakeCurrent(NULL, NULL); j2d_wglDeleteContext(context); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); return 0L; } // get config-specific capabilities j2d_wglGetPixelFormatAttribivARB(hdc, pixfmt, 0, 2, attrKeys, attrVals); if (attrVals[0]) { caps |= CAPS_DOUBLEBUFFERED; } if (attrVals[1] > 0) { caps |= CAPS_STORED_ALPHA; } // create the scratch pbuffer scratch = j2d_wglCreatePbufferARB(hdc, pixfmt, 1, 1, NULL); // destroy the temporary resources j2d_wglMakeCurrent(NULL, NULL); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); if (scratch == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: could not create scratch surface"); j2d_wglDeleteContext(context); return 0L; } // get the HDC for the scratch pbuffer scratchDC = j2d_wglGetPbufferDCARB(scratch); if (scratchDC == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: could not get hdc for scratch surface"); j2d_wglDeleteContext(context); j2d_wglDestroyPbufferARB(scratch); return 0L; } // initialize the OGLContext, which wraps the pixfmt and HGLRC (context) oglc = WGLGC_InitOGLContext(pixfmt, context, scratch, scratchDC, caps); if (oglc == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: could not create oglc"); j2d_wglDeleteContext(context); j2d_wglReleasePbufferDCARB(scratch, scratchDC); j2d_wglDestroyPbufferARB(scratch); return 0L; } J2dTraceLn(J2D_TRACE_VERBOSE, "WGLGraphicsConfig_getWGLConfigInfo: finished checking dependencies"); // create the WGLGraphicsConfigInfo record for this config wglinfo = (WGLGraphicsConfigInfo *)malloc(sizeof(WGLGraphicsConfigInfo)); if (wglinfo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGraphicsConfig_getWGLConfigInfo: could not allocate memory for wglinfo"); WGLGC_DestroyOGLContext(oglc); return 0L; } wglinfo->screen = screennum; wglinfo->pixfmt = pixfmt; wglinfo->context = oglc; return ptr_to_jlong(wglinfo); }
/** * Checks for the presence of the optional extensions used by * the Java 2D OpenGL pipeline. The given caps bitfield is updated * to reflect the availability of these extensions. */ void OGLContext_GetExtensionInfo(JNIEnv *env, jint *caps) { jint vcap = OGLC_VENDOR_OTHER; const char *vendor = (char *)j2d_glGetString(GL_VENDOR); const char *e = (char *)j2d_glGetString(GL_EXTENSIONS); jboolean fragShaderAvail = OGLContext_IsExtensionAvailable(e, "GL_ARB_fragment_shader"); J2dTraceLn(J2D_TRACE_INFO, "OGLContext_GetExtensionInfo"); *caps |= CAPS_TEXNONSQUARE; if (OGLContext_IsExtensionAvailable(e, "GL_ARB_multitexture")) { *caps |= CAPS_MULTITEXTURE; } if (OGLContext_IsExtensionAvailable(e, "GL_ARB_texture_non_power_of_two")) { *caps |= CAPS_TEXNONPOW2; } // 6656574: Use of the GL_ARB_texture_rectangle extension by Java 2D // complicates any third-party libraries that try to interact with // the OGL pipeline (and we've run into driver bugs in the past related // to this extension), so for now we will disable its use by default (unless // forced). We will still make use of the GL_ARB_texture_non_power_of_two // extension when available, which is the better choice going forward // anyway. if (OGLContext_IsExtensionAvailable(e, "GL_ARB_texture_rectangle") && getenv("J2D_OGL_TEXRECT") != NULL) { *caps |= CAPS_EXT_TEXRECT; } if (OGLContext_IsFBObjectExtensionAvailable(env, e)) { *caps |= CAPS_EXT_FBOBJECT; } if (OGLContext_IsLCDShaderSupportAvailable(env, fragShaderAvail)) { *caps |= CAPS_EXT_LCD_SHADER | CAPS_PS20; } if (OGLContext_IsBIOpShaderSupportAvailable(env, fragShaderAvail)) { *caps |= CAPS_EXT_BIOP_SHADER | CAPS_PS20; } if (OGLContext_IsGradShaderSupportAvailable(env, fragShaderAvail)) { *caps |= CAPS_EXT_GRAD_SHADER | CAPS_PS20; } if (OGLContext_IsExtensionAvailable(e, "GL_NV_fragment_program")) { // this is an Nvidia board, at least PS 2.0, but we can't // use the "max instructions" heuristic since GeForce FX // boards report 1024 even though they're only PS 2.0, // so we'll check the following, which does imply PS 3.0 if (OGLContext_IsExtensionAvailable(e, "GL_NV_fragment_program2")) { *caps |= CAPS_PS30; } } else { // for all other boards, we look at the "max instructions" // count reported by the GL_ARB_fragment_program extension // as a heuristic for detecting PS 3.0 compatible hardware if (OGLContext_IsExtensionAvailable(e, "GL_ARB_fragment_program")) { GLint instr; j2d_glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, &instr); if (instr > 512) { *caps |= CAPS_PS30; } } } if (OGLContext_IsExtensionAvailable(e, "GL_NV_texture_barrier")) { *caps |= CAPS_EXT_TEXBARRIER; } // stuff vendor descriptor in the upper bits of the caps if (vendor != NULL) { if (strncmp(vendor, "ATI", 3) == 0) { vcap = OGLC_VENDOR_ATI; } else if (strncmp(vendor, "NVIDIA", 6) == 0) { vcap = OGLC_VENDOR_NVIDIA; } else if (strncmp(vendor, "Intel", 5) == 0) { vcap = OGLC_VENDOR_INTEL; } // REMIND: new in 7 - check if needs fixing *caps |= ((vcap & OGLC_VCAP_MASK) << OGLC_VCAP_OFFSET); } }
/** * Determines whether the WGL pipeline can be used for a given GraphicsConfig * provided its screen number and visual ID. If the minimum requirements are * met, the native WGLGraphicsConfigInfo structure is initialized for this * GraphicsConfig with the necessary information (pixel format, etc.) * and a pointer to this structure is returned as a jlong. If * initialization fails at any point, zero is returned, indicating that WGL * cannot be used for this GraphicsConfig (we should fallback on the existing * DX pipeline). */ static jlong WGLGC_GetWGLConfigInfo(JNIEnv *env, jint screennum, jint pixfmt) { PIXELFORMATDESCRIPTOR pfd; HWND hwnd; HDC hdc; HGLRC context; WGLGraphicsConfigInfo *wglinfo; const unsigned char *versionstr; const char *extstr; int attr[] = { WGL_DOUBLE_BUFFER_ARB, 0 }; int db; J2dTraceLn(J2D_TRACE_INFO, "in WGLGC_GetWGLConfigInfo"); // initialize GL/WGL extension functions if (!WGLGC_InitExtFuncs(screennum)) { J2dTraceLn(J2D_TRACE_ERROR, "could not initialize extension funcs"); return 0L; } // create the WGLGraphicsConfigInfo record for this config wglinfo = (WGLGraphicsConfigInfo *)malloc(sizeof(WGLGraphicsConfigInfo)); if (wglinfo == NULL) { J2dTraceLn(J2D_TRACE_ERROR, "could not allocate memory for wglinfo"); return 0L; } // create a scratch window hwnd = WGLGC_CreateScratchWindow(screennum); if (hwnd == 0) { free(wglinfo); return 0L; } // get the HDC for the scratch window hdc = GetDC(hwnd); if (hdc == 0) { J2dTraceLn(J2D_TRACE_ERROR, "could not get dc for scratch window"); DestroyWindow(hwnd); free(wglinfo); return 0L; } if (pixfmt == 0) { // find an appropriate pixel format pixfmt = WGLGC_GetPixelFormatForDC(hdc); if (pixfmt == 0) { J2dTraceLn(J2D_TRACE_ERROR, "could not find appropriate pixfmt"); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); free(wglinfo); return 0L; } } // set the pixel format for the scratch window if (!SetPixelFormat(hdc, pixfmt, &pfd)) { J2dTraceLn(J2D_TRACE_ERROR, "error setting pixel format"); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); free(wglinfo); return 0L; } // create a temporary context context = j2d_wglCreateContext(hdc); if (context == 0) { J2dTraceLn(J2D_TRACE_ERROR, "could not create temp WGL context"); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); free(wglinfo); return 0L; } // make the context current so that we can query the OpenGL version // and extension strings if (!j2d_wglMakeCurrent(hdc, context)) { J2dTraceLn(J2D_TRACE_ERROR, "could not make temp context current"); j2d_wglDeleteContext(context); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); free(wglinfo); return 0L; } // invalidate the current context OGLContext_InvalidateCurrentContext(env); // get version and extension strings versionstr = j2d_glGetString(GL_VERSION); extstr = j2d_wglGetExtensionsStringARB(hdc); OGLContext_GetExtensionInfo(&wglinfo->extInfo); J2dTraceLn1(J2D_TRACE_INFO, "OpenGL version: %s", versionstr); if (!OGLContext_IsVersionSupported(versionstr)) { J2dTraceLn(J2D_TRACE_ERROR, "invalid OpenGL version; 1.2 is required"); j2d_wglMakeCurrent(NULL, NULL); j2d_wglDeleteContext(context); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); free(wglinfo); return 0L; } // check for required WGL extensions if (!OGLContext_IsExtensionAvailable(extstr, "WGL_ARB_pbuffer") || !OGLContext_IsExtensionAvailable(extstr, "WGL_ARB_render_texture") || !OGLContext_IsExtensionAvailable(extstr, "WGL_ARB_pixel_format")) { J2dTraceLn(J2D_TRACE_ERROR, "required extension(s) not available"); j2d_wglMakeCurrent(NULL, NULL); j2d_wglDeleteContext(context); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); free(wglinfo); return 0L; } // check whether pixel format is double buffered j2d_wglGetPixelFormatAttribivARB(hdc, pixfmt, 0, 1, attr, &db); // destroy the temporary resources j2d_wglMakeCurrent(NULL, NULL); j2d_wglDeleteContext(context); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); J2dTraceLn(J2D_TRACE_VERBOSE, "successfully finished checking dependencies"); wglinfo->screen = screennum; wglinfo->pixfmt = pixfmt; wglinfo->isDoubleBuffered = db; // create the single shared context (if it hasn't been created already) if (sharedContext == NULL) { if (WGLGC_InitSharedContext(env, wglinfo) == SD_FAILURE) { J2dTraceLn(J2D_TRACE_ERROR, "could not init shared context"); free(wglinfo); return 0L; } } return ptr_to_jlong(wglinfo); }
/** * Determines whether the GLX pipeline can be used for a given GraphicsConfig * provided its screen number and visual ID. If the minimum requirements are * met, the native GLXGraphicsConfigInfo structure is initialized for this * GraphicsConfig with the necessary information (pthread key, GLXFBConfig, * etc.) and a pointer to this structure is returned as a jlong. If * initialization fails at any point, zero is returned, indicating that GLX * cannot be used for this GraphicsConfig (we should fallback on the existing * X11 pipeline). */ static jlong GLXGC_GetGLXConfigInfo(JNIEnv *env, jint screennum, jint visnum) { GLXFBConfig fbconfig; GLXContext context; GLXPbuffer glxpbuffer; int pbattrlist[] = {GLX_PBUFFER_WIDTH, 1, GLX_PBUFFER_HEIGHT, 1, GLX_PRESERVED_CONTENTS, GL_FALSE, 0}; GLXGraphicsConfigInfo *glxinfo; int db; const unsigned char *versionstr; J2dTraceLn(J2D_TRACE_INFO, "in GLXGC_GetGLXConfigInfo"); fbconfig = GLXGC_InitFBConfig(env, screennum, visnum); if (fbconfig == 0) { J2dTraceLn(J2D_TRACE_ERROR, "could not create fbconfig"); return 0; } glxinfo = (GLXGraphicsConfigInfo *)malloc(sizeof(GLXGraphicsConfigInfo)); if (glxinfo == NULL) { J2dTraceLn(J2D_TRACE_ERROR, "could not allocate memory for glxinfo"); return 0; } // create a temporary context, used for querying OpenGL version and // extensions context = j2d_glXCreateNewContext(awt_display, fbconfig, GLX_RGBA_TYPE, NULL, GL_TRUE); if (context == 0) { J2dTraceLn(J2D_TRACE_ERROR, "could not create temp GLX context"); free(glxinfo); return 0; } // this is pretty sketchy, but it seems to be the easiest way to create // some form of GLXDrawable using only the display and a GLXFBConfig // (in order to make the context current for checking the version, // extensions, etc)... glxpbuffer = j2d_glXCreatePbuffer(awt_display, fbconfig, pbattrlist); if (glxpbuffer == 0) { J2dTraceLn(J2D_TRACE_ERROR, "could not create scratch pbuffer"); j2d_glXDestroyContext(awt_display, context); free(glxinfo); return 0; } // the temporary context must be made current before we can query the // version and extension strings j2d_glXMakeContextCurrent(awt_display, glxpbuffer, glxpbuffer, context); versionstr = j2d_glGetString(GL_VERSION); OGLContext_GetExtensionInfo(&glxinfo->extInfo); // destroy the temporary resources j2d_glXMakeContextCurrent(awt_display, None, None, NULL); j2d_glXDestroyPbuffer(awt_display, glxpbuffer); j2d_glXDestroyContext(awt_display, context); // invalidate the current context OGLContext_InvalidateCurrentContext(env); J2dTraceLn(J2D_TRACE_VERBOSE, "finished with temporary pbuffer/context"); J2dTraceLn1(J2D_TRACE_INFO, "OpenGL version: %s", versionstr); if (!OGLContext_IsVersionSupported(versionstr)) { J2dTraceLn(J2D_TRACE_ERROR, "invalid OpenGL version; 1.2 is required"); free(glxinfo); return 0; } J2dTraceLn(J2D_TRACE_VERBOSE, "successfully finished checking dependencies"); j2d_glXGetFBConfigAttrib(awt_display, fbconfig, GLX_DOUBLEBUFFER, &db); glxinfo->screen = screennum; glxinfo->visual = visnum; glxinfo->fbconfig = fbconfig; glxinfo->isDoubleBuffered = db; // create the single shared context (if it hasn't been created already) if (sharedContext == NULL) { if (GLXGC_InitSharedContext(env, glxinfo) == SD_FAILURE) { J2dTraceLn(J2D_TRACE_ERROR, "could not init shared context"); free(glxinfo); return 0; } } return ptr_to_jlong(glxinfo); }
/** * Determines whether the GLX pipeline can be used for a given GraphicsConfig * provided its screen number and visual ID. If the minimum requirements are * met, the native GLXGraphicsConfigInfo structure is initialized for this * GraphicsConfig with the necessary information (GLXFBConfig, etc.) * and a pointer to this structure is returned as a jlong. If * initialization fails at any point, zero is returned, indicating that GLX * cannot be used for this GraphicsConfig (we should fallback on the existing * X11 pipeline). */ JNIEXPORT jlong JNICALL Java_sun_java2d_opengl_GLXGraphicsConfig_getGLXConfigInfo(JNIEnv *env, jclass glxgc, jint screennum, jint visnum) { #ifndef HEADLESS OGLContext *oglc; GLXFBConfig fbconfig; GLXContext context; GLXPbuffer scratch; GLXGraphicsConfigInfo *glxinfo; jint caps = CAPS_EMPTY; int db, alpha; const unsigned char *versionstr; J2dRlsTraceLn(J2D_TRACE_INFO, "GLXGraphicsConfig_getGLXConfigInfo"); if (usingXinerama) { // when Xinerama is enabled, the screen ID needs to be 0 screennum = 0; } fbconfig = GLXGC_InitFBConfig(env, screennum, (VisualID)visnum); if (fbconfig == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGraphicsConfig_getGLXConfigInfo: could not create fbconfig"); return 0L; } if (sharedContext == 0) { // create the one shared context sharedContext = j2d_glXCreateNewContext(awt_display, fbconfig, GLX_RGBA_TYPE, 0, GL_TRUE); if (sharedContext == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGraphicsConfig_getGLXConfigInfo: could not create shared context"); return 0L; } } // create the GLXContext for this GLXGraphicsConfig context = j2d_glXCreateNewContext(awt_display, fbconfig, GLX_RGBA_TYPE, sharedContext, GL_TRUE); if (context == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGraphicsConfig_getGLXConfigInfo: could not create GLX context"); return 0L; } // this is pretty sketchy, but it seems to be the easiest way to create // some form of GLXDrawable using only the display and a GLXFBConfig // (in order to make the context current for checking the version, // extensions, etc)... scratch = GLXGC_InitScratchPbuffer(fbconfig); if (scratch == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGraphicsConfig_getGLXConfigInfo: could not create scratch pbuffer"); j2d_glXDestroyContext(awt_display, context); return 0L; } // the context must be made current before we can query the // version and extension strings j2d_glXMakeContextCurrent(awt_display, scratch, scratch, context); #ifdef __sparc /* * 6438225: The software rasterizer used by Sun's OpenGL libraries * for certain boards has quality issues, and besides, performance * of these boards is not high enough to justify the use of the * OpenGL-based Java 2D pipeline. If we detect one of the following * boards via the GL_RENDERER string, just give up: * - FFB[2[+]] ("Creator[3D]") * - PGX-series ("m64") * - AFB ("Elite3D") */ { const char *renderer = (const char *)j2d_glGetString(GL_RENDERER); J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "GLXGraphicsConfig_getGLXConfigInfo: detected renderer (%s)", (renderer == NULL) ? "null" : renderer); if (renderer == NULL || strncmp(renderer, "Creator", 7) == 0 || strncmp(renderer, "SUNWm64", 7) == 0 || strncmp(renderer, "Elite", 5) == 0) { J2dRlsTraceLn1(J2D_TRACE_ERROR, "GLXGraphicsConfig_getGLXConfigInfo: unsupported board (%s)", (renderer == NULL) ? "null" : renderer); j2d_glXMakeContextCurrent(awt_display, None, None, NULL); j2d_glXDestroyPbuffer(awt_display, scratch); j2d_glXDestroyContext(awt_display, context); return 0L; } } #endif /* __sparc */ versionstr = j2d_glGetString(GL_VERSION); OGLContext_GetExtensionInfo(env, &caps); // destroy the temporary resources j2d_glXMakeContextCurrent(awt_display, None, None, NULL); J2dRlsTraceLn1(J2D_TRACE_INFO, "GLXGraphicsConfig_getGLXConfigInfo: OpenGL version=%s", (versionstr == NULL) ? "null" : (char *)versionstr); if (!OGLContext_IsVersionSupported(versionstr)) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGraphicsConfig_getGLXConfigInfo: OpenGL 1.2 is required"); j2d_glXDestroyPbuffer(awt_display, scratch); j2d_glXDestroyContext(awt_display, context); return 0L; } // get config-specific capabilities j2d_glXGetFBConfigAttrib(awt_display, fbconfig, GLX_DOUBLEBUFFER, &db); if (db) { caps |= CAPS_DOUBLEBUFFERED; } j2d_glXGetFBConfigAttrib(awt_display, fbconfig, GLX_ALPHA_SIZE, &alpha); if (alpha > 0) { caps |= CAPS_STORED_ALPHA; } // initialize the OGLContext, which wraps the GLXFBConfig and GLXContext oglc = GLXGC_InitOGLContext(fbconfig, context, scratch, caps); if (oglc == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGraphicsConfig_getGLXConfigInfo: could not create oglc"); j2d_glXDestroyPbuffer(awt_display, scratch); j2d_glXDestroyContext(awt_display, context); return 0L; } J2dTraceLn(J2D_TRACE_VERBOSE, "GLXGraphicsConfig_getGLXConfigInfo: finished checking dependencies"); // create the GLXGraphicsConfigInfo record for this config glxinfo = (GLXGraphicsConfigInfo *)malloc(sizeof(GLXGraphicsConfigInfo)); if (glxinfo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGraphicsConfig_getGLXConfigInfo: could not allocate memory for glxinfo"); GLXGC_DestroyOGLContext(oglc); return 0L; } glxinfo->screen = screennum; glxinfo->visual = visnum; glxinfo->context = oglc; glxinfo->fbconfig = fbconfig; return ptr_to_jlong(glxinfo); #else return 0L; #endif /* !HEADLESS */ }