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;
}
