jboolean OGLFuncs_OpenLibrary() { J2dRlsTraceLn(J2D_TRACE_INFO, "OGLFuncs_OpenLibrary"); OGL_OPEN_LIB(); if (OGL_LIB_IS_UNINITIALIZED()) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLFuncs_OpenLibrary: could not open library"); return JNI_FALSE; } return JNI_TRUE; }
/** * Attempts to initialize GLX and the core OpenGL library. For this method * to return JNI_TRUE, the following must be true: * - libGL must be loaded successfully (via dlopen) * - all function symbols from libGL must be available and loaded properly * - the GLX extension must be available through X11 * - client GLX version must be >= 1.3 * If any of these requirements are not met, this method will return * JNI_FALSE, indicating there is no hope of using GLX/OpenGL for any * GraphicsConfig in the environment. */ static jboolean GLXGC_InitGLX() { int errorbase, eventbase; const char *version; J2dRlsTraceLn(J2D_TRACE_INFO, "GLXGC_InitGLX"); if (!OGLFuncs_OpenLibrary()) { return JNI_FALSE; } if (!OGLFuncs_InitPlatformFuncs() || !OGLFuncs_InitBaseFuncs() || !OGLFuncs_InitExtFuncs()) { OGLFuncs_CloseLibrary(); return JNI_FALSE; } if (!j2d_glXQueryExtension(awt_display, &errorbase, &eventbase)) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGC_InitGLX: GLX extension is not present"); OGLFuncs_CloseLibrary(); return JNI_FALSE; } version = j2d_glXGetClientString(awt_display, GLX_VERSION); if (version == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGC_InitGLX: could not query GLX version"); OGLFuncs_CloseLibrary(); return JNI_FALSE; } // we now only verify that the client GLX version is >= 1.3 (if the // server does not support GLX 1.3, then we will find that out later // when we attempt to create a GLXFBConfig) J2dRlsTraceLn1(J2D_TRACE_INFO, "GLXGC_InitGLX: client GLX version=%s", version); if (!((version[0] == '1' && version[2] >= '3') || (version[0] > '1'))) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGC_InitGLX: invalid GLX version; 1.3 is required"); OGLFuncs_CloseLibrary(); return JNI_FALSE; } return JNI_TRUE; }
HRESULT D3DPipelineManager::InitAdapters() { HRESULT res = E_FAIL; J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::InitAdapters()"); if (pAdapters != NULL) { ReleaseAdapters(); } adapterCount = pd3d9->GetAdapterCount(); pAdapters = new D3DAdapter[adapterCount]; if (pAdapters == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "InitAdapters: out of memory"); adapterCount = 0; return E_FAIL; } ZeroMemory(pAdapters, adapterCount * sizeof(D3DAdapter)); res = CheckAdaptersInfo(); RETURN_STATUS_IF_FAILED(res); currentFSFocusAdapter = -1; if (CreateDefaultFocusWindow() == 0) { return E_FAIL; } return S_OK; }
void OGLFuncs_CloseLibrary() { J2dRlsTraceLn(J2D_TRACE_INFO, "OGLFuncs_CloseLibrary"); if (OGL_LIB_IS_UNINITIALIZED()) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLFuncs_CloseLibrary: library not yet initialized"); return; } if (OGL_CLOSE_LIB()) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLFuncs_CloseLibrary: could not close library"); } }
/** * Creates a new GlyphCacheInfo structure, fills in the initial values, and * then returns a pointer to the GlyphCacheInfo record. * * Note that this method only sets up a data structure describing a * rectangular region of accelerated memory, containing "virtual" cells of * the requested size. The cell information is added lazily to the linked * list describing the cache as new glyphs are added. Platform specific * glyph caching code is responsible for actually creating the accelerated * memory surface that will contain the individual glyph images. */ GlyphCacheInfo * AccelGlyphCache_Init(jint width, jint height, jint cellWidth, jint cellHeight, FlushFunc *func) { GlyphCacheInfo *gcinfo; J2dTraceLn(J2D_TRACE_INFO, "AccelGlyphCache_Init"); gcinfo = (GlyphCacheInfo *)malloc(sizeof(GlyphCacheInfo)); if (gcinfo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "AccelGlyphCache_Init: could not allocate GlyphCacheInfo"); return NULL; } gcinfo->head = NULL; gcinfo->tail = NULL; gcinfo->width = width; gcinfo->height = height; gcinfo->cellWidth = cellWidth; gcinfo->cellHeight = cellHeight; gcinfo->isFull = JNI_FALSE; gcinfo->Flush = func; return gcinfo; }
/** * Disposes all memory and resources allocated for the given OGLContext. */ static void GLXGC_DestroyOGLContext(OGLContext *oglc) { GLXCtxInfo *ctxinfo; J2dTraceLn(J2D_TRACE_INFO, "GLXGC_DestroyOGLContext"); if (oglc == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGC_DestroyOGLContext: context is null"); return; } // at this point, this context will be current to its scratch surface // so the following GL/GLX operations should be safe... OGLContext_DestroyContextResources(oglc); ctxinfo = (GLXCtxInfo *)oglc->ctxInfo; if (ctxinfo != NULL) { // release the current context before we continue j2d_glXMakeContextCurrent(awt_display, None, None, NULL); if (ctxinfo->context != 0) { j2d_glXDestroyContext(awt_display, ctxinfo->context); } if (ctxinfo->scratchSurface != 0) { j2d_glXDestroyPbuffer(awt_display, ctxinfo->scratchSurface); } free(ctxinfo); } free(oglc); }
/** * Makes the given GraphicsConfig's context current to its associated * "scratch" surface. If there is a problem making the context current, * this method will return NULL; otherwise, returns a pointer to the * OGLContext that is associated with the given GraphicsConfig. */ OGLContext * OGLSD_SetScratchSurface(JNIEnv *env, jlong pConfigInfo) { GLXGraphicsConfigInfo *glxInfo = (GLXGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo); OGLContext *oglc; J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SetScratchContext"); if (glxInfo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_SetScratchContext: glx config info is null"); return NULL; } oglc = glxInfo->context; if (!GLXSD_MakeCurrentToScratch(env, oglc)) { return NULL; } if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) { // the GL_EXT_framebuffer_object extension is present, so this call // will ensure that we are bound to the scratch pbuffer (and not // some other framebuffer object) j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); } return oglc; }
/** * Compiles and links the LCD text shader program. If successful, this * function returns a handle to the newly created shader program; otherwise * returns 0. */ static GLhandleARB OGLTR_CreateLCDTextProgram() { GLhandleARB lcdTextProgram; GLint loc; J2dTraceLn(J2D_TRACE_INFO, "OGLTR_CreateLCDTextProgram"); lcdTextProgram = OGLContext_CreateFragmentProgram(lcdTextShaderSource); if (lcdTextProgram == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLTR_CreateLCDTextProgram: error creating program"); return 0; } // "use" the program object temporarily so that we can set the uniforms j2d_glUseProgramObjectARB(lcdTextProgram); // set the "uniform" values loc = j2d_glGetUniformLocationARB(lcdTextProgram, "glyph_tex"); j2d_glUniform1iARB(loc, 0); // texture unit 0 loc = j2d_glGetUniformLocationARB(lcdTextProgram, "dst_tex"); j2d_glUniform1iARB(loc, 1); // texture unit 1 loc = j2d_glGetUniformLocationARB(lcdTextProgram, "invgamma_tex"); j2d_glUniform1iARB(loc, 2); // texture unit 2 loc = j2d_glGetUniformLocationARB(lcdTextProgram, "gamma_tex"); j2d_glUniform1iARB(loc, 3); // texture unit 3 // "unuse" the program object; it will be re-bound later as needed j2d_glUseProgramObjectARB(0); return lcdTextProgram; }
/** * Creates a temporary (non-visible) window that can be used for querying * the OpenGL capabilities of a given device. * * REMIND: should be able to create a window on a specific device... */ HWND WGLGC_CreateScratchWindow(jint screennum) { static jboolean firsttime = JNI_TRUE; J2dTraceLn(J2D_TRACE_INFO, "WGLGC_CreateScratchWindow"); if (firsttime) { WNDCLASS wc; // setup window class information ZeroMemory(&wc, sizeof(WNDCLASS)); wc.hInstance = GetModuleHandle(NULL); wc.lpfnWndProc = DefWindowProc; wc.lpszClassName = L"Tmp"; if (RegisterClass(&wc) == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGC_CreateScratchWindow: error registering window class"); return 0; } firsttime = JNI_FALSE; } // create scratch window return CreateWindow(L"Tmp", L"Tmp", 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, GetModuleHandle(NULL), NULL); }
/** * Returns JNI_TRUE if the given extension name is available for the current * GraphicsConfig; JNI_FALSE otherwise. An extension is considered available * if its identifier string is found amongst the space-delimited GL_EXTENSIONS * string. * * Adapted from the OpenGL Red Book, pg. 506. */ jboolean OGLContext_IsExtensionAvailable(const char *extString, char *extName) { jboolean ret = JNI_FALSE; char *p = (char *)extString; char *end; if (extString == NULL) { J2dTraceLn(J2D_TRACE_INFO, "OGLContext_IsExtensionAvailable"); J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLContext_IsExtensionAvailable: extension string is null"); return JNI_FALSE; } end = p + strlen(p); while (p < end) { size_t n = strcspn(p, " "); if ((strlen(extName) == n) && (strncmp(extName, p, n) == 0)) { ret = JNI_TRUE; break; } p += (n + 1); } J2dRlsTraceLn2(J2D_TRACE_INFO, "OGLContext_IsExtensionAvailable: %s=%s", extName, ret ? "true" : "false"); return ret; }
HRESULT D3DGlyphCache::Init(D3DContext *pCtx) { D3DFORMAT format; RETURN_STATUS_IF_NULL(pCtx, E_FAIL); J2dTraceLn1(J2D_TRACE_INFO, "D3DGlyphCache::Init pCtx=%x", pCtx); this->pCtx = pCtx; if (pGlyphCache == NULL) { // init glyph cache data structure pGlyphCache = AccelGlyphCache_Init(D3DTR_CACHE_WIDTH, D3DTR_CACHE_HEIGHT, D3DTR_CACHE_CELL_WIDTH, D3DTR_CACHE_CELL_HEIGHT, D3DGlyphCache_FlushGlyphVertexCache); if (pGlyphCache == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "D3DGlyphCache::Init: "\ "could not init D3D glyph cache"); return E_FAIL; } } if (gcType == CACHE_GRAY) { format = pCtx->IsTextureFormatSupported(D3DFMT_A8) ? D3DFMT_A8 : D3DFMT_A8R8G8B8; } else { // gcType == CACHE_LCD format = pCtx->IsTextureFormatSupported(D3DFMT_R8G8B8) ? D3DFMT_R8G8B8 : D3DFMT_A8R8G8B8; } HRESULT res = pCtx->GetResourceManager()-> CreateTexture(D3DTR_CACHE_WIDTH, D3DTR_CACHE_HEIGHT, FALSE/*isRTT*/, FALSE/*isOpaque*/, &format, 0/*usage*/, &pGlyphCacheRes); if (FAILED(res)) { J2dRlsTraceLn(J2D_TRACE_ERROR, "D3DGlyphCache::Init: "\ "could not create glyph cache texture"); } return res; }
/** * This function initializes a native window surface and caches the window * bounds in the given OGLSDOps. Returns JNI_TRUE if the operation was * successful; JNI_FALSE otherwise. */ jboolean OGLSD_InitOGLWindow(JNIEnv *env, OGLSDOps *oglsdo) { GLXSDOps *glxsdo; Window window; XWindowAttributes attr; J2dTraceLn(J2D_TRACE_INFO, "OGLSD_InitOGLWindow"); if (oglsdo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: ops are null"); return JNI_FALSE; } glxsdo = (GLXSDOps *)oglsdo->privOps; if (glxsdo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: glx ops are null"); return JNI_FALSE; } window = glxsdo->window; if (window == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: window is invalid"); return JNI_FALSE; } XGetWindowAttributes(awt_display, window, &attr); oglsdo->width = attr.width; oglsdo->height = attr.height; oglsdo->drawableType = OGLSD_WINDOW; oglsdo->isOpaque = JNI_TRUE; oglsdo->xOffset = 0; oglsdo->yOffset = 0; glxsdo->drawable = window; glxsdo->xdrawable = window; J2dTraceLn2(J2D_TRACE_VERBOSE, " created window: w=%d h=%d", oglsdo->width, oglsdo->height); return JNI_TRUE; }
// static HRESULT D3DPipelineManager::GDICheckForBadHardware() { DISPLAY_DEVICE dd; dd.cb = sizeof(DISPLAY_DEVICE); int failedDevices = 0; int attachedDevices = 0; int i = 0; WCHAR *id; WCHAR vendorId[5]; WCHAR deviceId[5]; DWORD dwDId, dwVId; J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::GDICheckForBadHardware"); // i<20 is to guard against buggy drivers while (EnumDisplayDevices(NULL, i, &dd, 0) && i < 20) { if (dd.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) { attachedDevices++; id = dd.DeviceID; if (wcslen(id) > 21) { // get vendor ID wcsncpy(vendorId, id+8, 4); int args1 = swscanf(vendorId, L"%X", &dwVId); // get device ID wcsncpy(deviceId, id+17, 4); int args2 = swscanf(deviceId, L"%X", &dwDId); if (args1 == 1 && args2 == 1) { J2dTraceLn2(J2D_TRACE_VERBOSE, " device: vendorID=0x%04x, deviceId=0x%04x", dwVId, dwDId); // since we don't have a driver version here we will // just ask to ignore the version for now; bad hw // entries with specific drivers information will be // processed later when d3d is initialized and we can // obtain a driver version if (FAILED(CheckForBadHardware(dwVId, dwDId, MAX_VERSION))){ failedDevices++; } } } } i++; } if (failedDevices == attachedDevices) { J2dRlsTraceLn(J2D_TRACE_ERROR, "D3DPPLM::GDICheckForBadHardware: no suitable devices found"); return E_FAIL; } return S_OK; }
jboolean OGLFuncs_InitBaseFuncs() { J2dRlsTraceLn(J2D_TRACE_INFO, "OGLFuncs_InitBaseFuncs"); if (OGL_LIB_IS_UNINITIALIZED()) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLFuncs_InitBaseFuncs: library not yet initialized"); return JNI_FALSE; } OGL_EXPRESS_BASE_FUNCS(INIT_AND_CHECK) J2dTraceLn(J2D_TRACE_VERBOSE, "OGLFuncs_InitBaseFuncs: successfully loaded base symbols"); return JNI_TRUE; }
/** * Creates a context that is compatible with the given pixel format * identifier. Returns 0 if the context could not be created properly. */ static HGLRC WGLGC_CreateContext(jint screennum, jint pixfmt) { PIXELFORMATDESCRIPTOR pfd; HWND hwnd; HDC hdc; HGLRC hglrc; J2dTraceLn(J2D_TRACE_INFO, "WGLGC_CreateContext"); hwnd = WGLGC_CreateScratchWindow(screennum); if (hwnd == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGC_CreateContext: could not create scratch window"); return 0; } // get the HDC for the scratch window hdc = GetDC(hwnd); if (hdc == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGC_CreateContext: could not get dc for scratch window"); DestroyWindow(hwnd); return 0; } // set the pixel format for the scratch window if (!SetPixelFormat(hdc, pixfmt, &pfd)) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLGC_CreateContext: error setting pixel format"); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); return 0; } // create a context based on the scratch window hglrc = j2d_wglCreateContext(hdc); // release the temporary resources ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); return hglrc; }
/** * Initializes an OpenGL texture, using the given width and height as * a guide. See OGLSD_InitTextureObject() for more information. */ JNIEXPORT jboolean JNICALL Java_sun_java2d_opengl_OGLSurfaceData_initTexture (JNIEnv *env, jobject oglsd, jlong pData, jboolean isOpaque, jboolean texNonPow2, jboolean texRect, jint width, jint height) { OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData); J2dTraceLn2(J2D_TRACE_INFO, "OGLSurfaceData_initTexture: w=%d h=%d", width, height); if (oglsdo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSurfaceData_initTexture: ops are null"); return JNI_FALSE; } /* * We only use the GL_ARB_texture_rectangle extension if it is available * and the requested bounds are not pow2 (it is probably faster to use * GL_TEXTURE_2D for pow2 textures, and besides, our TexturePaint * code relies on GL_REPEAT, which is not allowed for * GL_TEXTURE_RECTANGLE_ARB targets). */ texRect = texRect && !OGLSD_IsPowerOfTwo(width, height); if (!OGLSD_InitTextureObject(oglsdo, isOpaque, texNonPow2, texRect, width, height)) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSurfaceData_initTexture: could not init texture object"); return JNI_FALSE; } OGLSD_SetNativeDimensions(env, oglsdo, oglsdo->textureWidth, oglsdo->textureHeight); oglsdo->drawableType = OGLSD_TEXTURE; // other fields (e.g. width, height) are set in OGLSD_InitTextureObject() return JNI_TRUE; }
/** * Returns a pointer (as a jlong) to the native WGLGraphicsConfigInfo * associated with the given OGLSDOps. This method can be called from * shared code to retrieve the native GraphicsConfig data in a platform- * independent manner. */ jlong OGLSD_GetNativeConfigInfo(OGLSDOps *oglsdo) { WGLSDOps *wglsdo; if (oglsdo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: ops are null"); return 0L; } wglsdo = (WGLSDOps *)oglsdo->privOps; if (wglsdo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: wgl ops are null"); return 0L; } return ptr_to_jlong(wglsdo->configInfo); }
/** * Returns JNI_TRUE only if all of the following conditions are met: * - the GL_ARB_fragment_shader extension is available * - the BufferedImageOp shader codepath has been enabled via the * system property */ static jboolean OGLContext_IsBIOpShaderSupportAvailable(JNIEnv *env, jboolean fragShaderAvailable) { jboolean isBIOpShaderEnabled = JNI_FALSE; J2dTraceLn(J2D_TRACE_INFO, "OGLContext_IsBIOpShaderSupportAvailable"); // first see if the fragment shader extension is available if (!fragShaderAvailable) { return JNI_FALSE; } // next see if the biopshader system property has been enabled isBIOpShaderEnabled = JNU_GetStaticFieldByName(env, NULL, "sun/java2d/opengl/OGLSurfaceData", "isBIOpShaderEnabled", "Z").z; if (!isBIOpShaderEnabled) { J2dRlsTraceLn(J2D_TRACE_INFO, "OGLContext_IsBIOpShaderSupportAvailable: disabled via flag"); return JNI_FALSE; } /* * Note: In theory we should probably do some other checks here, like * linking a sample shader to see if the hardware truly supports our * shader programs. However, our current BufferedImageOp shaders were * designed to support first-generation shader-level hardware, so the * assumption is that if our shaders work on those GPUs, then they'll * work on newer ones as well. Also, linking a fragment program can * cost valuable CPU cycles, which is another reason to avoid these * checks at startup. */ J2dRlsTraceLn(J2D_TRACE_INFO, "OGLContext_IsBIOpShaderSupportAvailable: BufferedImageOp shader supported"); return JNI_TRUE; }
/** * Initializes a surface in the backbuffer of a given double-buffered * onscreen window for use in a BufferStrategy.Flip situation. The bounds of * the backbuffer surface should always be kept in sync with the bounds of * the underlying native window. */ JNIEXPORT jboolean JNICALL Java_sun_java2d_opengl_OGLSurfaceData_initFlipBackbuffer (JNIEnv *env, jobject oglsd, jlong pData) { OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData); J2dTraceLn(J2D_TRACE_INFO, "OGLSurfaceData_initFlipBackbuffer"); if (oglsdo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSurfaceData_initFlipBackbuffer: ops are null"); return JNI_FALSE; } if (oglsdo->drawableType == OGLSD_UNDEFINED) { if (!OGLSD_InitOGLWindow(env, oglsdo)) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSurfaceData_initFlipBackbuffer: could not init window"); return JNI_FALSE; } } if (oglsdo->drawableType != OGLSD_WINDOW) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSurfaceData_initFlipBackbuffer: drawable is not a window"); return JNI_FALSE; } oglsdo->drawableType = OGLSD_FLIP_BACKBUFFER; // x/yOffset have already been set in OGLSD_InitOGLWindow()... // REMIND: for some reason, flipping won't work properly on IFB unless we // explicitly use BACK_LEFT rather than BACK... oglsdo->activeBuffer = GL_BACK_LEFT; OGLSD_SetNativeDimensions(env, oglsdo, oglsdo->width, oglsdo->height); return JNI_TRUE; }
/** * Returns JNI_TRUE only if all of the following conditions are met: * - the GL_ARB_fragment_shader extension is available * - the LCD text shader codepath has been enabled via the system property * - the hardware supports the minimum number of texture units */ static jboolean OGLContext_IsLCDShaderSupportAvailable(JNIEnv *env, jboolean fragShaderAvailable) { jboolean isLCDShaderEnabled = JNI_FALSE; GLint maxTexUnits; J2dTraceLn(J2D_TRACE_INFO, "OGLContext_IsLCDShaderSupportAvailable"); // first see if the fragment shader extension is available if (!fragShaderAvailable) { return JNI_FALSE; } // next see if the lcdshader system property has been enabled isLCDShaderEnabled = JNU_GetStaticFieldByName(env, NULL, "sun/java2d/opengl/OGLSurfaceData", "isLCDShaderEnabled", "Z").z; if (!isLCDShaderEnabled) { J2dRlsTraceLn(J2D_TRACE_INFO, "OGLContext_IsLCDShaderSupportAvailable: disabled via flag"); return JNI_FALSE; } // finally, check to see if the hardware supports the required number // of texture units j2d_glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &maxTexUnits); if (maxTexUnits < 2) { J2dRlsTraceLn1(J2D_TRACE_INFO, "OGLContext_IsLCDShaderSupportAvailable: not enough tex units (%d)", maxTexUnits); } J2dRlsTraceLn(J2D_TRACE_INFO, "OGLContext_IsLCDShaderSupportAvailable: LCD text shader supported"); return JNI_TRUE; }
/** * Makes the given context current to its associated "scratch" surface. If * the operation is successful, this method will return JNI_TRUE; otherwise, * returns JNI_FALSE. */ static jboolean WGLSD_MakeCurrentToScratch(JNIEnv *env, OGLContext *oglc) { WGLCtxInfo *ctxInfo; J2dTraceLn(J2D_TRACE_INFO, "WGLSD_MakeCurrentToScratch"); if (oglc == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLSD_MakeCurrentToScratch: context is null"); return JNI_FALSE; } ctxInfo = (WGLCtxInfo *)oglc->ctxInfo; if (!j2d_wglMakeCurrent(ctxInfo->scratchSurfaceDC, ctxInfo->context)) { J2dRlsTraceLn(J2D_TRACE_ERROR, "WGLSD_MakeCurrentToScratch: could not make current"); return JNI_FALSE; } return JNI_TRUE; }
void OGLSD_SwapBuffers(JNIEnv *env, jlong window) { J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SwapBuffers"); if (window == 0L) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_SwapBuffers: window is null"); return; } j2d_glXSwapBuffers(awt_display, (Window)window); }
// static HRESULT D3DPipelineManager::CheckOSVersion() { // require Windows XP or newer client-class OS if (IS_WINVER_ATLEAST(5, 1) && !D3DPPLM_OsVersionMatches(OS_WINSERV_2008|OS_WINSERV_2003)) { J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::CheckOSVersion: Windows XP or newer client-classs"\ " OS detected, passed"); return S_OK; } J2dRlsTraceLn(J2D_TRACE_ERROR, "D3DPPLM::CheckOSVersion: Windows 2000 or earlier (or a "\ "server) OS detected, failed"); if (bNoHwCheck) { J2dRlsTraceLn(J2D_TRACE_WARNING, " OS check overridden via J2D_D3D_NO_HWCHECK"); return S_OK; } return E_FAIL; }
/** * Returns the X11 VisualID that corresponds to the best GLXFBConfig for the * given screen. If no valid visual could be found, this method returns zero. * Note that this method will attempt to initialize GLX (and all the * necessary function symbols) if it has not been already. The AWT_LOCK * must be acquired before calling this method. */ VisualID GLXGC_FindBestVisual(JNIEnv *env, jint screen) { GLXFBConfig fbc; XVisualInfo *xvi; VisualID visualid; J2dRlsTraceLn1(J2D_TRACE_INFO, "GLXGC_FindBestVisual: scn=%d", screen); if (!GLXGC_IsGLXAvailable()) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGC_FindBestVisual: could not initialize GLX"); return 0; } fbc = GLXGC_InitFBConfig(env, screen, 0); if (fbc == 0) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGC_FindBestVisual: could not find best visual"); return 0; } xvi = j2d_glXGetVisualFromFBConfig(awt_display, fbc); if (xvi == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "GLXGC_FindBestVisual: could not get visual for fbconfig"); return 0; } visualid = xvi->visualid; XFree(xvi); J2dRlsTraceLn2(J2D_TRACE_INFO, "GLXGC_FindBestVisual: chose 0x%x as the best visual for screen %d", visualid, screen); return visualid; }
// Creates a Direct3D9 object and initializes adapters. // If succeeded, returns S_OK, otherwise returns the error code. HRESULT D3DPipelineManager::InitD3D(void) { typedef IDirect3D9 * WINAPI FnDirect3DCreate9(UINT SDKVersion); hLibD3D9 = ::LoadLibrary(TEXT("d3d9.dll")); if (hLibD3D9 == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "InitD3D: no d3d9.dll"); return E_FAIL; } FnDirect3DCreate9 *d3dcreate9 = NULL; d3dcreate9 = (FnDirect3DCreate9*) ::GetProcAddress(hLibD3D9, "Direct3DCreate9"); if (d3dcreate9 == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "InitD3D: no Direct3DCreate9"); ::FreeLibrary(hLibD3D9); return E_FAIL; } pd3d9 = d3dcreate9(D3D_SDK_VERSION); if (pd3d9 == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "InitD3D: unable to create IDirect3D9 object"); ::FreeLibrary(hLibD3D9); return E_FAIL; } HRESULT res; if (FAILED(res = InitAdapters())) { J2dRlsTraceLn(J2D_TRACE_ERROR, "InitD3D: failed to init adapters"); ReleaseD3D(); return res; } return S_OK; }
/** * Returns JNI_TRUE if the given GL_VERSION string meets the minimum * requirements (>= 1.2); JNI_FALSE otherwise. */ jboolean OGLContext_IsVersionSupported(const unsigned char *versionstr) { J2dTraceLn(J2D_TRACE_INFO, "OGLContext_IsVersionSupported"); if (versionstr == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLContext_IsVersionSupported: version string is null"); return JNI_FALSE; } // note that this check allows for OpenGL 2.x return ((versionstr[0] == '1' && versionstr[2] >= '2') || (versionstr[0] >= '2')); }
JNIEXPORT jint JNICALL Java_sun_java2d_opengl_OGLSurfaceData_getTextureID (JNIEnv *env, jobject oglsd, jlong pData) { OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData); J2dTraceLn(J2D_TRACE_INFO, "OGLSurfaceData_getTextureID"); if (oglsdo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSurfaceData_getTextureID: ops are null"); return 0L; } return (jint)oglsdo->textureID; }
/** * Attempts to initialize WGL and the core OpenGL library. For this method * to return JNI_TRUE, the following must be true: * - opengl32.dll must be loaded successfully (via LoadLibrary) * - all core WGL/OGL function symbols from opengl32.dll must be * available and loaded properly * If any of these requirements are not met, this method will return * JNI_FALSE, indicating there is no hope of using WGL/OpenGL for any * GraphicsConfig in the environment. */ JNIEXPORT jboolean JNICALL Java_sun_java2d_opengl_WGLGraphicsConfig_initWGL(JNIEnv *env, jclass wglgc) { J2dRlsTraceLn(J2D_TRACE_INFO, "WGLGraphicsConfig_initWGL"); if (!OGLFuncs_OpenLibrary()) { return JNI_FALSE; } if (!OGLFuncs_InitPlatformFuncs() || !OGLFuncs_InitBaseFuncs()) { OGLFuncs_CloseLibrary(); return JNI_FALSE; } return JNI_TRUE; }
HRESULT D3DPIPELINE_API D3DRenderer_DrawPoly(D3DContext *d3dc, jint nPoints, jboolean isClosed, jint transX, jint transY, jint *xPoints, jint *yPoints) { J2dTraceLn(J2D_TRACE_INFO, "D3DRenderer_DrawPoly"); if (d3dc == NULL || xPoints == NULL || yPoints == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "D3DRenderer_DrawPoly: d3dc, xPoints or yPoints is NULL"); return E_FAIL; } d3dc->BeginScene(STATE_RENDEROP); return d3dc->pVCacher->DrawPoly(nPoints, isClosed, transX, transY, xPoints, yPoints); }
/** * Initializes the one glyph cache (texture and data structure). * If lcdCache is JNI_TRUE, the texture will contain RGB data, * otherwise we will simply store the grayscale/monochrome glyph images * as intensity values (which work well with the GL_MODULATE function). */ static jboolean OGLTR_InitGlyphCache(jboolean lcdCache) { GlyphCacheInfo *gcinfo; GLclampf priority = 1.0f; GLenum internalFormat = lcdCache ? GL_RGB8 : GL_INTENSITY8; GLenum pixelFormat = lcdCache ? GL_RGB : GL_LUMINANCE; J2dTraceLn(J2D_TRACE_INFO, "OGLTR_InitGlyphCache"); // init vertex cache (if it hasn't been already) if (!OGLVertexCache_InitVertexCache()) { return JNI_FALSE; } // init glyph cache data structure gcinfo = AccelGlyphCache_Init(OGLTR_CACHE_WIDTH, OGLTR_CACHE_HEIGHT, OGLTR_CACHE_CELL_WIDTH, OGLTR_CACHE_CELL_HEIGHT, OGLVertexCache_FlushVertexCache); if (gcinfo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLTR_InitGlyphCache: could not init OGL glyph cache"); return JNI_FALSE; } // init cache texture object j2d_glGenTextures(1, &gcinfo->cacheID); j2d_glBindTexture(GL_TEXTURE_2D, gcinfo->cacheID); j2d_glPrioritizeTextures(1, &gcinfo->cacheID, &priority); j2d_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); j2d_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); j2d_glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, OGLTR_CACHE_WIDTH, OGLTR_CACHE_HEIGHT, 0, pixelFormat, GL_UNSIGNED_BYTE, NULL); cacheStatus = (lcdCache ? CACHE_LCD : CACHE_GRAY); glyphCache = gcinfo; return JNI_TRUE; }