/**
* Disposes all memory and resources allocated for the given OGLContext,
* which was previously stored in thread-local storage and is about to be
* destroyed.
*/
static void
WGLGC_DestroyOGLContext(JNIEnv *env, OGLContext *oglc)
{
J2dTraceLn(J2D_TRACE_INFO, "in WGLGC_DestroyOGLContext");
if (oglc != NULL) {
WGLCtxInfo *ctxinfo = (WGLCtxInfo *)oglc->ctxInfo;
// invalidate the current context
OGLContext_InvalidateCurrentContext(env);
j2d_wglMakeCurrent(NULL, NULL);
if (ctxinfo != NULL) {
j2d_wglDeleteContext(ctxinfo->context);
free(ctxinfo);
}
if (oglc->xformMatrix != NULL) {
free(oglc->xformMatrix);
}
if (oglc->maskTextureID != 0) {
j2d_glDeleteTextures(1, &oglc->maskTextureID);
}
if (oglc->blitTextureID != 0) {
j2d_glDeleteTextures(1, &oglc->blitTextureID);
}
free(oglc);
}
}
/**
* Disposes all memory and resources allocated for the given OGLContext,
* which was previously stored in thread-local storage and is about to be
* destroyed.
*/
static void
GLXGC_DestroyOGLContext(JNIEnv *env, OGLContext *oglc)
{
J2dTraceLn(J2D_TRACE_INFO, "in GLXGC_DestroyOGLContext");
if (oglc != NULL) {
GLXCtxInfo *ctxinfo = (GLXCtxInfo *)oglc->ctxInfo;
// invalidate the current context
OGLContext_InvalidateCurrentContext(env);
j2d_glXMakeContextCurrent(awt_display, None, None, NULL);
if (ctxinfo != NULL) {
j2d_glXDestroyContext(awt_display, ctxinfo->context);
free(ctxinfo);
}
if (oglc->xformMatrix != NULL) {
free(oglc->xformMatrix);
}
if (oglc->maskTextureID != 0) {
j2d_glDeleteTextures(1, &oglc->maskTextureID);
}
if (oglc->blitTextureID != 0) {
j2d_glDeleteTextures(1, &oglc->blitTextureID);
}
free(oglc);
}
}
/**
* 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);
}
