HWND D3DPipelineManager::SetFSFocusWindow(UINT adapterOrdinal, HWND hWnd)
{
J2dTraceLn2(J2D_TRACE_INFO,"D3DPPLM::SetFSFocusWindow hwnd=0x%x adapter=%d",
hWnd, adapterOrdinal);
HWND prev = pAdapters[adapterOrdinal].fsFocusWindow;
pAdapters[adapterOrdinal].fsFocusWindow = hWnd;
if (currentFSFocusAdapter < 0) {
J2dTraceLn(J2D_TRACE_VERBOSE, " first full-screen window");
// first fs window
currentFSFocusAdapter = adapterOrdinal;
// REMIND: we might want to reset the rest of the context here as well
// like we do when the an adapter exits fs mode; currently they will
// be reset sometime later
} else {
// there's already a fs window
if (currentFSFocusAdapter == adapterOrdinal) {
// it's current fs window => we're exiting fs mode on this adapter;
// look for a new fs focus window
if (hWnd == 0) {
UINT i;
currentFSFocusAdapter = -1;
for (i = 0; i < adapterCount; i++) {
if (pAdapters[i].fsFocusWindow != 0) {
J2dTraceLn1(J2D_TRACE_VERBOSE,
" adapter %d is still in fs mode", i);
currentFSFocusAdapter = i;
break;
}
}
// we have to reset all devices any time current focus device
// exits fs mode, and also to prevent some of them being left in
// a lost state when the last device exits fs - when non-last
// adapters exit fs mode they would not be able to create the
// device and will be put in a lost state forever
HRESULT res;
J2dTraceLn(J2D_TRACE_VERBOSE,
" adapter exited full-screen, reset all adapters");
for (i = 0; i < adapterCount; i++) {
if (pAdapters[i].pd3dContext != NULL) {
res = pAdapters[i].pd3dContext->ResetContext();
D3DRQ_MarkLostIfNeeded(res,
D3DRQ_GetCurrentDestination());
}
}
} else {
J2dTraceLn1(J2D_TRACE_WARNING,
"D3DPM::SetFSFocusWindow: setting the fs "\
"window again for adapter %d", adapterOrdinal);
}
}
}
return prev;
}
HWND D3DPipelineManager::GetCurrentFocusWindow()
{
J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::GetCurrentFocusWindow");
if (currentFSFocusAdapter < 0) {
J2dTraceLn1(J2D_TRACE_VERBOSE,
" no fs windows, using default focus window=0x%x",
defaultFocusWindow);
return defaultFocusWindow;
}
J2dTraceLn1(J2D_TRACE_VERBOSE, " using fs window=0x%x",
pAdapters[currentFSFocusAdapter].fsFocusWindow);
return pAdapters[currentFSFocusAdapter].fsFocusWindow;
}
/**
* Disposes of all native resources associated with this surface.
*/
void
OGLSD_Flush(JNIEnv *env, OGLSDOps *oglsdo)
{
J2dTraceLn1(J2D_TRACE_INFO, "OGLSD_Flush: type=%d",
oglsdo->drawableType);
if (oglsdo->drawableType == OGLSD_TEXTURE) {
if (oglsdo->textureID != 0) {
j2d_glDeleteTextures(1, &oglsdo->textureID);
oglsdo->textureID = 0;
}
} else if (oglsdo->drawableType == OGLSD_FBOBJECT) {
if (oglsdo->textureID != 0) {
j2d_glDeleteTextures(1, &oglsdo->textureID);
oglsdo->textureID = 0;
}
if (oglsdo->depthID != 0) {
j2d_glDeleteRenderbuffersEXT(1, &oglsdo->depthID);
oglsdo->depthID = 0;
}
if (oglsdo->fbobjectID != 0) {
j2d_glDeleteFramebuffersEXT(1, &oglsdo->fbobjectID);
oglsdo->fbobjectID = 0;
}
} else {
// dispose windowing system resources (pbuffer, pixmap, etc)
OGLSD_DestroyOGLSurface(env, oglsdo);
}
}
/**
* This function invokes the native threadsafe flushing and unlocking
* mechanism (e.g. the AWT_FLUSH_UNLOCK() macro in the GLX case) to ensure
* the preceding OpenGL commands are completed before the surface is unlocked
* in a synchronized manner. See OGLSurfaceData.h for more information
* on the recognized constant values for the flushFlag parameter.
*/
void
OGLSD_UnlockImpl(JNIEnv *env, jint flushFlag)
{
J2dTraceLn1(J2D_TRACE_INFO, "in OGLSD_UnlockImpl (flush=%d)", flushFlag);
switch (flushFlag) {
case OGLSD_FLUSH_ON_JED:
// if we're on the JED thread, we can use the native Toolkit thread
// flushing mechanism, which will post an asynchronous event that will
// eventually flush the context that is current to this thread
needGLFlush = JNI_TRUE;
AWT_FLUSH_UNLOCK();
break;
case OGLSD_FLUSH_NOW:
// otherwise, we have no choice but to flush immediately (or else
// any rendering not invoked from the JED thread could be left
// unflushed)
j2d_glFlush();
// FALLTHROUGH
case OGLSD_NO_FLUSH:
default:
AWT_UNLOCK();
break;
}
}
void
OGLPaints_ResetPaint(OGLContext *oglc)
{
jubyte ea;
J2dTraceLn(J2D_TRACE_INFO, "OGLPaints_ResetPaint");
RETURN_IF_NULL(oglc);
J2dTraceLn1(J2D_TRACE_VERBOSE, " state=%d", oglc->paintState);
RESET_PREVIOUS_OP();
if (oglc->useMask) {
// switch to texture unit 1, where paint state is currently enabled
j2d_glActiveTextureARB(GL_TEXTURE1_ARB);
}
switch (oglc->paintState) {
case sun_java2d_SunGraphics2D_PAINT_GRADIENT:
j2d_glDisable(GL_TEXTURE_1D);
j2d_glDisable(GL_TEXTURE_GEN_S);
break;
case sun_java2d_SunGraphics2D_PAINT_TEXTURE:
// Note: The texture object used in SetTexturePaint() will
// still be bound at this point, so it is safe to call the following.
OGLSD_RESET_TEXTURE_WRAP(GL_TEXTURE_2D);
j2d_glDisable(GL_TEXTURE_2D);
j2d_glDisable(GL_TEXTURE_GEN_S);
j2d_glDisable(GL_TEXTURE_GEN_T);
break;
case sun_java2d_SunGraphics2D_PAINT_LIN_GRADIENT:
case sun_java2d_SunGraphics2D_PAINT_RAD_GRADIENT:
j2d_glUseProgramObjectARB(0);
j2d_glDisable(GL_TEXTURE_1D);
break;
case sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR:
default:
break;
}
if (oglc->useMask) {
// restore control to texture unit 0
j2d_glActiveTextureARB(GL_TEXTURE0_ARB);
}
// set each component of the current color state to the extra alpha
// value, which will effectively apply the extra alpha to each fragment
// in paint/texturing operations
ea = (jubyte)(oglc->extraAlpha * 0xff + 0.5f);
j2d_glColor4ub(ea, ea, ea, ea);
oglc->pixel = (ea << 24) | (ea << 16) | (ea << 8) | (ea << 0);
oglc->r = ea;
oglc->g = ea;
oglc->b = ea;
oglc->a = ea;
oglc->useMask = JNI_FALSE;
oglc->paintState = -1;
}
/*
* Class: sun_java2d_d3d_D3DGraphicsDevice
* Method: getAvailableAcceleratedMemoryNative
* Signature: (I)J
*/
JNIEXPORT jlong JNICALL
Java_sun_java2d_d3d_D3DGraphicsDevice_getAvailableAcceleratedMemoryNative
(JNIEnv *env, jclass gdc, jint gdiScreen)
{
// REMIND: looks like Direct3D provides information about texture memory
// only via IDirect3DDevice9::GetAvailableTextureMem, however, it
// seems to report the same amount as direct draw used to.
HRESULT res;
D3DPipelineManager *pMgr;
D3DContext *pCtx;
IDirect3DDevice9 *pd3dDevice;
UINT adapter;
J2dTraceLn(J2D_TRACE_INFO, "D3DGD_getAvailableAcceleratedMemoryNative");
RETURN_STATUS_IF_NULL(pMgr = D3DPipelineManager::GetInstance(), 0L);
adapter = pMgr->GetAdapterOrdinalForScreen(gdiScreen);
if (FAILED(res = pMgr->GetD3DContext(adapter, &pCtx))) {
D3DRQ_MarkLostIfNeeded(res, D3DRQ_GetCurrentDestination());
return 0L;
}
RETURN_STATUS_IF_NULL(pd3dDevice = pCtx->Get3DDevice(), 0L);
UINT mem = pd3dDevice->GetAvailableTextureMem();
J2dTraceLn1(J2D_TRACE_VERBOSE, " available memory=%d", mem);
return mem;
}
/**
* Returns a pixel format identifier that is suitable for Java 2D's needs
* (must have a stencil buffer, support for pbuffers, etc). If no
* appropriate pixel format can be found, this method returns 0.
*/
static int
WGLGC_GetPixelFormatForDC(HDC hdc)
{
int attrs[] = {
WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
WGL_DRAW_TO_PBUFFER_ARB, GL_TRUE,
WGL_BIND_TO_TEXTURE_RGB_ARB, GL_TRUE,
WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
WGL_STENCIL_BITS_ARB, 1,
0
};
int pixfmt;
int nfmts;
J2dTraceLn(J2D_TRACE_INFO, "in WGLGC_GetPixelFormatForDC");
// find pixel format
if (!j2d_wglChoosePixelFormatARB(hdc, attrs, NULL, 1, &pixfmt, &nfmts)) {
J2dTraceLn(J2D_TRACE_ERROR, "error choosing pixel format");
return 0;
}
if (nfmts <= 0) {
J2dTraceLn(J2D_TRACE_ERROR, "no pixel formats found");
return 0;
}
J2dTraceLn1(J2D_TRACE_VERBOSE, "chose pixel format: %d", pixfmt);
return pixfmt;
}
/*
* Class: sun_java2d_windows_WinBackBufferSurfaceData
* Method: initSurface
* Signature: (IIILsun/awt/windows/WinBackBufferSurfaceData;)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_windows_WinBackBufferSurfaceData_initSurface(JNIEnv *env,
jobject sData, jint depth, jint width, jint height, jint screen,
jobject parentData)
{
Win32SDOps *wsdo = (Win32SDOps *)SurfaceData_GetOps(env, sData);
J2dTraceLn(J2D_TRACE_INFO, "Win32BBSD_initSurface");
/* Set the correct dispose method */
wsdo->sdOps.Dispose = Win32BBSD_Dispose;
jboolean status =
initOSSD_WSDO(env, wsdo, width, height, screen, JNI_FALSE);
if (status == JNI_FALSE || parentData == NULL) {
SurfaceData_ThrowInvalidPipeException(env,
"Error initalizing back-buffer surface");
return;
}
Win32SDOps *wsdo_parent = (Win32SDOps*)SurfaceData_GetOps(env, parentData);
if (!DDGetAttachedSurface(env, wsdo_parent, wsdo)) {
SurfaceData_ThrowInvalidPipeException(env,
"Can't create attached surface");
}
J2dTraceLn1(J2D_TRACE_VERBOSE,
"Win32BackBufferSurfaceData_initSurface: "\
"completed wsdo->lpSurface=0x%x", wsdo->lpSurface);
}
/**
* Initializes the OpenGL logic op state to XOR mode. Blending is disabled
* before enabling logic op mode. The XOR pixel value will be applied
* later in the OGLContext_SetColor() method.
*/
void
OGLContext_SetXorComposite(OGLContext *oglc, jint xorPixel)
{
J2dTraceLn1(J2D_TRACE_INFO,
"OGLContext_SetXorComposite: xorPixel=%08x", xorPixel);
RETURN_IF_NULL(oglc);
CHECK_PREVIOUS_OP(OGL_STATE_CHANGE);
// disable blending mode
if (oglc->compState == sun_java2d_SunGraphics2D_COMP_ALPHA) {
j2d_glDisable(GL_BLEND);
}
// enable XOR mode
j2d_glEnable(GL_COLOR_LOGIC_OP);
j2d_glLogicOp(GL_XOR);
// set up the alpha test so that we discard transparent fragments (this
// is primarily useful for rendering text in XOR mode)
j2d_glEnable(GL_ALPHA_TEST);
j2d_glAlphaFunc(GL_NOTEQUAL, 0.0f);
// update state
oglc->compState = sun_java2d_SunGraphics2D_COMP_XOR;
oglc->xorPixel = xorPixel;
oglc->extraAlpha = 1.0f;
}
/**
* Updates the current gamma-adjusted source color ("src_adj") of the LCD
* text shader program. Note that we could calculate this value in the
* shader (e.g. just as we do for "dst_adj"), but would be unnecessary work
* (and a measurable performance hit, maybe around 5%) since this value is
* constant over the entire glyph list. So instead we just calculate the
* gamma-adjusted value once and update the uniform parameter of the LCD
* shader as needed.
*/
static HRESULT
D3DTR_UpdateLCDTextColor(D3DContext *d3dc, jint contrast)
{
IDirect3DDevice9 *pd3dDevice = d3dc->Get3DDevice();
jfloat gamma = ((jfloat)contrast) / 100.0f;
jfloat clr[4];
J2dTraceLn1(J2D_TRACE_INFO,
"D3DTR_UpdateLCDTextColor: contrast=%d", contrast);
/*
* Note: Ideally we would update the "srcAdj" uniform parameter only
* when there is a change in the source color. Fortunately, the cost
* of querying the current D3D color state and updating the uniform
* value is quite small, and in the common case we only need to do this
* once per GlyphList, so we gain little from trying to optimize too
* eagerly here.
*/
// get the current D3D primary color state
jint color = d3dc->pVCacher->GetColor();
clr[0] = (jfloat)((color >> 16) & 0xff) / 255.0f;
clr[1] = (jfloat)((color >> 8) & 0xff) / 255.0f;
clr[2] = (jfloat)((color >> 0) & 0xff) / 255.0f;
clr[3] = 0.0f; // unused
// gamma adjust the primary color
clr[0] = (jfloat)pow(clr[0], gamma);
clr[1] = (jfloat)pow(clr[1], gamma);
clr[2] = (jfloat)pow(clr[2], gamma);
// update the "srcAdj" parameter of the shader program with this value
return pd3dDevice->SetPixelShaderConstantF(0, clr, 1);
}
/**
* Add a reference to the array. This could be someone that wants
* to register interest in the array, versus someone that actually
* holds a reference to an array item (in which case they would
* call GetDeviceReference() instead). This mechanism can keep
* the array from being deleted when it has no elements being
* referenced but is still a valid array to use for new elements
* or references.
*/
void Devices::AddReference()
{
J2dTraceLn(J2D_TRACE_INFO, "Devices::AddReference");
CriticalSection::Lock l(arrayLock);
refCount++;
J2dTraceLn1(J2D_TRACE_VERBOSE, " refCount=%d", refCount);
}
void
OGLPaints_SetColor(OGLContext *oglc, jint pixel)
{
jubyte r, g, b, a;
J2dTraceLn1(J2D_TRACE_INFO, "OGLPaints_SetColor: pixel=%08x", pixel);
RETURN_IF_NULL(oglc);
// glColor*() is allowed within glBegin()/glEnd() pairs, so
// no need to reset the current op state here unless the paint
// state really needs to be changed
if (oglc->paintState > sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR) {
OGLPaints_ResetPaint(oglc);
}
// store the raw (unmodified) pixel value, which may be used for
// special operations later
oglc->pixel = pixel;
if (oglc->compState != sun_java2d_SunGraphics2D_COMP_XOR) {
r = (jubyte)(pixel >> 16);
g = (jubyte)(pixel >> 8);
b = (jubyte)(pixel >> 0);
a = (jubyte)(pixel >> 24);
J2dTraceLn4(J2D_TRACE_VERBOSE,
" updating color: r=%02x g=%02x b=%02x a=%02x",
r, g, b, a);
} else {
/**
* Updates the current gamma-adjusted source color ("src_adj") of the LCD
* text shader program. Note that we could calculate this value in the
* shader (e.g. just as we do for "dst_adj"), but would be unnecessary work
* (and a measurable performance hit, maybe around 5%) since this value is
* constant over the entire glyph list. So instead we just calculate the
* gamma-adjusted value once and update the uniform parameter of the LCD
* shader as needed.
*/
static jboolean
OGLTR_UpdateLCDTextColor(jint contrast)
{
double gamma = ((double)contrast) / 100.0;
GLfloat radj, gadj, badj;
GLfloat clr[4];
GLint loc;
J2dTraceLn1(J2D_TRACE_INFO,
"OGLTR_UpdateLCDTextColor: contrast=%d", contrast);
/*
* Note: Ideally we would update the "src_adj" uniform parameter only
* when there is a change in the source color. Fortunately, the cost
* of querying the current OpenGL color state and updating the uniform
* value is quite small, and in the common case we only need to do this
* once per GlyphList, so we gain little from trying to optimize too
* eagerly here.
*/
// get the current OpenGL primary color state
j2d_glGetFloatv(GL_CURRENT_COLOR, clr);
// gamma adjust the primary color
radj = (GLfloat)pow(clr[0], gamma);
gadj = (GLfloat)pow(clr[1], gamma);
badj = (GLfloat)pow(clr[2], gamma);
// update the "src_adj" parameter of the shader program with this value
loc = j2d_glGetUniformLocationARB(lcdTextProgram, "src_adj");
j2d_glUniform3fARB(loc, radj, gadj, badj);
return JNI_TRUE;
}
HRESULT D3DPipelineManager::GetD3DContext(UINT adapterOrdinal,
D3DContext **ppd3dContext)
{
J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::GetD3DContext");
HRESULT res = S_OK;
if (adapterOrdinal < 0 || adapterOrdinal >= adapterCount ||
pAdapters == NULL ||
pAdapters[adapterOrdinal].state == CONTEXT_INIT_FAILED)
{
J2dRlsTraceLn1(J2D_TRACE_ERROR,
"D3DPPLM::GetD3DContext: invalid parameters or "\
"failed init for adapter %d", adapterOrdinal);
*ppd3dContext = NULL;
return E_FAIL;
}
if (pAdapters[adapterOrdinal].state == CONTEXT_NOT_INITED) {
D3DContext *pCtx = NULL;
if (pAdapters[adapterOrdinal].pd3dContext != NULL) {
J2dTraceLn1(J2D_TRACE_ERROR, " non-null context in "\
"uninitialized adapter %d", adapterOrdinal);
res = E_FAIL;
} else {
J2dTraceLn1(J2D_TRACE_VERBOSE,
" initializing context for adapter %d",adapterOrdinal);
if (SUCCEEDED(res = D3DEnabledOnAdapter(adapterOrdinal))) {
res = D3DContext::CreateInstance(pd3d9, adapterOrdinal, &pCtx);
if (FAILED(res)) {
J2dRlsTraceLn1(J2D_TRACE_ERROR,
"D3DPPLM::GetD3DContext: failed to create context "\
"for adapter=%d", adapterOrdinal);
}
} else {
J2dRlsTraceLn1(J2D_TRACE_ERROR,
"D3DPPLM::GetContext: no d3d on adapter %d",adapterOrdinal);
}
}
pAdapters[adapterOrdinal].state =
SUCCEEDED(res) ? CONTEXT_CREATED : CONTEXT_INIT_FAILED;
pAdapters[adapterOrdinal].pd3dContext = pCtx;
}
*ppd3dContext = pAdapters[adapterOrdinal].pd3dContext;
return res;
}
/**
* Create a new Devices object with numDevices elements.
*/
Devices::Devices(int numDevices)
{
J2dTraceLn1(J2D_TRACE_INFO, "Devices::Devices numDevices=%d", numDevices);
this->numDevices = numDevices;
this->refCount = 0;
devices = (AwtWin32GraphicsDevice**)SAFE_SIZE_ARRAY_ALLOC(safe_Malloc,
numDevices, sizeof(AwtWin32GraphicsDevice *));
}
/**
* Create a new Devices object with numDevices elements.
*/
Devices::Devices(int numDevices)
{
J2dTraceLn1(J2D_TRACE_INFO, "Devices::Devices numDevices=%d", numDevices);
this->numDevices = numDevices;
this->refCount = 0;
devices = (AwtWin32GraphicsDevice**)safe_Malloc
(numDevices * sizeof(AwtWin32GraphicsDevice *));
}
HRESULT
D3DMaskCache::Init(D3DContext *pCtx)
{
J2dTraceLn1(J2D_TRACE_INFO, "D3DMaskCache::Init pCtx=%x", pCtx);
this->pCtx = pCtx;
this->maskCacheIndex = 0;
return S_OK;
}
// static
HRESULT D3DPipelineManager::HandleAdaptersChange(HMONITOR *pHMONITORs, UINT monNum)
{
HRESULT res = S_OK;
BOOL bResetD3D = FALSE, bFound;
D3DPipelineManager *pMgr = D3DPipelineManager::GetInstance();
RETURN_STATUS_IF_NULL(pHMONITORs, E_FAIL);
if (pMgr == NULL) {
// NULL pMgr is valid when the pipeline is not enabled or if it hasn't
// been created yet
return S_OK;
}
RETURN_STATUS_IF_NULL(pMgr->pAdapters, E_FAIL);
RETURN_STATUS_IF_NULL(pMgr->pd3d9, E_FAIL);
J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::HandleAdaptersChange");
if (monNum != pMgr->adapterCount) {
J2dTraceLn2(J2D_TRACE_VERBOSE,
" number of adapters changed (old=%d, new=%d)",
pMgr->adapterCount, monNum);
bResetD3D = TRUE;
} else {
for (UINT i = 0; i < pMgr->adapterCount; i++) {
HMONITOR hMon = pMgr->pd3d9->GetAdapterMonitor(i);
if (hMon == (HMONITOR)0x0) {
J2dTraceLn1(J2D_TRACE_VERBOSE, " adapter %d: removed", i);
bResetD3D = TRUE;
break;
}
bFound = FALSE;
for (UINT mon = 0; mon < monNum; mon++) {
if (pHMONITORs[mon] == hMon) {
J2dTraceLn3(J2D_TRACE_VERBOSE,
" adapter %d: found hmnd[%d]=0x%x", i, mon, hMon);
bFound = TRUE;
break;
}
}
if (!bFound) {
J2dTraceLn2(J2D_TRACE_VERBOSE,
" adapter %d: could not find hmnd=0x%x "\
"in the list of new hmnds", i, hMon);
bResetD3D = TRUE;
break;
}
}
}
if (bResetD3D) {
J2dTraceLn(J2D_TRACE_VERBOSE, " adapters changed: resetting d3d");
pMgr->ReleaseD3D();
res = pMgr->InitD3D();
}
return res;
}
/**
* Returns a reference to a device with the passed index.
*
* This method does not increase the ref count of the Devices instance.
*
* This method must be called while holding a reference to the instance.
*/
AwtWin32GraphicsDevice *Devices::GetDevice(int index, BOOL adjust)
{
J2dTraceLn2(J2D_TRACE_INFO,
"Devices::GetDevice index=%d adjust?=%d",
index, adjust);
if (index < 0 || index >= numDevices) {
if (!adjust) {
J2dTraceLn1(J2D_TRACE_WARNING,
"Devices::GetDevice: "\
"incorrect index %d, returning NULL.", index);
return NULL;
}
J2dTraceLn1(J2D_TRACE_WARNING,
"Devices::GetDevice: "\
"adjusted index %d to 0.", index);
index = 0;
}
return devices[index];
}
/**
* Initializes the OpenGL state responsible for applying extra alpha. This
* step is only necessary for any operation that uses glDrawPixels() or
* glCopyPixels() with a non-1.0f extra alpha value. Since the source is
* always premultiplied, we apply the extra alpha value to both alpha and
* color components using GL_*_SCALE.
*/
void
OGLContext_SetExtraAlpha(jfloat ea)
{
J2dTraceLn1(J2D_TRACE_INFO, "OGLContext_SetExtraAlpha: ea=%f", ea);
j2d_glPixelTransferf(GL_ALPHA_SCALE, ea);
j2d_glPixelTransferf(GL_RED_SCALE, ea);
j2d_glPixelTransferf(GL_GREEN_SCALE, ea);
j2d_glPixelTransferf(GL_BLUE_SCALE, ea);
}
/*
* Class: sun_java2d_d3d_D3DGraphicsDevice
* Method: initD3D
* Signature: ()Z
*/
JNIEXPORT jboolean JNICALL Java_sun_java2d_d3d_D3DGraphicsDevice_initD3D
(JNIEnv *env, jclass)
{
J2dTraceLn(J2D_TRACE_INFO, "D3DGD_initD3D");
jboolean result = D3DInitializer::GetInstance().EnsureInited()
? JNI_TRUE : JNI_FALSE;
J2dTraceLn1(J2D_TRACE_INFO, "D3DGD_initD3D: result=%x", result);
return result;
}
D3DGlyphCache::D3DGlyphCache(GlyphCacheType type)
{
J2dTraceLn1(J2D_TRACE_INFO, "D3DGlyphCache::D3DGlyphCache gcType=%d", type);
pCtx = NULL;
gcType = type;
pGlyphCacheRes = NULL;
pGlyphCache = NULL;
tileFormat = (gcType == CACHE_GRAY) ? TILEFMT_1BYTE_ALPHA : TILEFMT_UNKNOWN;
lastRGBOrder = JNI_FALSE;
}
/**
* (Re)Initializes the gamma lookup table textures.
*
* The given contrast value is an int in the range [100, 250] which we will
* then scale to fit in the range [1.0, 2.5]. We create two LUTs, one
* that essentially calculates pow(x, gamma) and the other calculates
* pow(x, 1/gamma). These values are replicated in all three dimensions, so
* given a single 3D texture coordinate (typically this will be a triplet
* in the form (r,g,b)), the 3D texture lookup will return an RGB triplet:
*
* (pow(r,g), pow(y,g), pow(z,g)
*
* where g is either gamma or 1/gamma, depending on the table.
*/
static jboolean
OGLTR_UpdateLCDTextContrast(jint contrast)
{
double gamma = ((double)contrast) / 100.0;
double ig = gamma;
double g = 1.0 / ig;
GLfloat lut[LUT_EDGE][LUT_EDGE][LUT_EDGE][3];
GLfloat invlut[LUT_EDGE][LUT_EDGE][LUT_EDGE][3];
int min = 0;
int max = LUT_EDGE - 1;
int x, y, z;
J2dTraceLn1(J2D_TRACE_INFO,
"OGLTR_UpdateLCDTextContrast: contrast=%d", contrast);
for (z = min; z <= max; z++) {
double zval = ((double)z) / max;
GLfloat gz = (GLfloat)pow(zval, g);
GLfloat igz = (GLfloat)pow(zval, ig);
for (y = min; y <= max; y++) {
double yval = ((double)y) / max;
GLfloat gy = (GLfloat)pow(yval, g);
GLfloat igy = (GLfloat)pow(yval, ig);
for (x = min; x <= max; x++) {
double xval = ((double)x) / max;
GLfloat gx = (GLfloat)pow(xval, g);
GLfloat igx = (GLfloat)pow(xval, ig);
lut[z][y][x][0] = gx;
lut[z][y][x][1] = gy;
lut[z][y][x][2] = gz;
invlut[z][y][x][0] = igx;
invlut[z][y][x][1] = igy;
invlut[z][y][x][2] = igz;
}
}
}
if (gammaLutTextureID == 0) {
gammaLutTextureID = OGLTR_InitGammaLutTexture();
}
OGLTR_UpdateGammaLutTexture(gammaLutTextureID, (GLfloat *)lut, LUT_EDGE);
if (invGammaLutTextureID == 0) {
invGammaLutTextureID = OGLTR_InitGammaLutTexture();
}
OGLTR_UpdateGammaLutTexture(invGammaLutTextureID,
(GLfloat *)invlut, LUT_EDGE);
return JNI_TRUE;
}
/**
* Debugging utility: prints information about errors received
* during interaction with the registry.
*/
void RegistryKey::PrintRegistryError(LONG errNum, char *message)
{
WCHAR errString[255];
int numChars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, errNum, 0,
errString, 255, NULL);
if (numChars == 0) {
J2dTraceLn1(J2D_TRACE_ERROR, "problem with formatmessage, err = %d\n",
GetLastError());
}
J2dTraceLn3(J2D_TRACE_ERROR, "problem with %s, errNum, string = %d, %S\n",
message, errNum, errString);
}
HWND D3DPipelineManager::CreateDefaultFocusWindow()
{
UINT adapterOrdinal = D3DADAPTER_DEFAULT;
J2dTraceLn1(J2D_TRACE_INFO,
"D3DPPLM::CreateDefaultFocusWindow: adapter=%d",
adapterOrdinal);
if (defaultFocusWindow != 0) {
J2dRlsTraceLn(J2D_TRACE_WARNING,
"D3DPPLM::CreateDefaultFocusWindow: "\
"existing default focus window!");
return defaultFocusWindow;
}
WNDCLASS wc;
ZeroMemory(&wc, sizeof(WNDCLASS));
wc.hInstance = GetModuleHandle(NULL);
wc.lpfnWndProc = DefWindowProc;
wc.lpszClassName = L"D3DFocusWindow";
if (RegisterClass(&wc) == 0) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"D3DPPLM::CreateDefaultFocusWindow: "\
"error registering window class");
return 0;
}
MONITORINFO mi;
ZeroMemory(&mi, sizeof(MONITORINFO));
mi.cbSize = sizeof(MONITORINFO);
HMONITOR hMon = pd3d9->GetAdapterMonitor(adapterOrdinal);
if (hMon == 0 || !GetMonitorInfo(hMon, (LPMONITORINFO)&mi)) {
J2dRlsTraceLn1(J2D_TRACE_ERROR,
"D3DPPLM::CreateDefaultFocusWindow: "\
"error getting monitor info for adapter=%d", adapterOrdinal);
return 0;
}
HWND hWnd = CreateWindow(L"D3DFocusWindow", L"D3DFocusWindow", 0,
mi.rcMonitor.left, mi.rcMonitor.top, 1, 1,
NULL, NULL, GetModuleHandle(NULL), NULL);
if (hWnd == 0) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"D3DPPLM::CreateDefaultFocusWindow: CreateWindow failed");
} else {
J2dTraceLn2(J2D_TRACE_INFO,
" Created default focus window %x for adapter %d",
hWnd, adapterOrdinal);
defaultFocusWindow = hWnd;
}
return hWnd;
}
/**
* Initializes the OpenGL blending state. XOR mode is disabled and the
* appropriate blend functions are setup based on the AlphaComposite rule
* constant.
*/
void
OGLContext_SetAlphaComposite(OGLContext *oglc,
jint rule, jfloat extraAlpha, jint flags)
{
J2dTraceLn1(J2D_TRACE_INFO,
"OGLContext_SetAlphaComposite: flags=%d", flags);
RETURN_IF_NULL(oglc);
CHECK_PREVIOUS_OP(OGL_STATE_CHANGE);
// disable XOR mode
if (oglc->compState == sun_java2d_SunGraphics2D_COMP_XOR) {
j2d_glDisable(GL_COLOR_LOGIC_OP);
j2d_glDisable(GL_ALPHA_TEST);
}
// we can safely disable blending when:
// - comp is SrcNoEa or SrcOverNoEa, and
// - the source is opaque
// (turning off blending can have a large positive impact on
// performance)
if ((rule == RULE_Src || rule == RULE_SrcOver) &&
(extraAlpha == 1.0f) &&
(flags & OGLC_SRC_IS_OPAQUE))
{
J2dTraceLn1(J2D_TRACE_VERBOSE,
" disabling alpha comp: rule=%d ea=1.0 src=opq", rule);
j2d_glDisable(GL_BLEND);
} else {
J2dTraceLn2(J2D_TRACE_VERBOSE,
" enabling alpha comp: rule=%d ea=%f", rule, extraAlpha);
j2d_glEnable(GL_BLEND);
j2d_glBlendFunc(StdBlendRules[rule].src, StdBlendRules[rule].dst);
}
// update state
oglc->compState = sun_java2d_SunGraphics2D_COMP_ALPHA;
oglc->extraAlpha = extraAlpha;
}
HRESULT
D3DResourceManager::Init(D3DContext *pCtx)
{
J2dTraceLn1(J2D_TRACE_INFO, "D3DRM::Init pCtx=%x", pCtx);
if (this->pCtx != pCtx ||
(this->pCtx != NULL &&
this->pCtx->Get3DDevice() != pCtx->Get3DDevice()))
{
ReleaseAll();
}
this->pCtx = pCtx;
return S_OK;
}
void GetFlagValues(JNIEnv *env, jclass wFlagsClass)
{
jboolean d3dEnabled = env->GetStaticBooleanField(wFlagsClass, d3dEnabledID);
jboolean d3dSet = env->GetStaticBooleanField(wFlagsClass, d3dSetID);
if (!d3dSet) {
// Only check environment variable if user did not set Java
// command-line parameter; values of sun.java2d.d3d override
// any setting of J2D_D3D environment variable.
char *d3dEnv = getenv("J2D_D3D");
if (d3dEnv) {
if (strcmp(d3dEnv, "false") == 0) {
// printf("Java2D Direct3D usage disabled by J2D_D3D env\n");
d3dEnabled = FALSE;
d3dSet = TRUE;
SetD3DEnabledFlag(env, d3dEnabled, d3dSet);
} else if (strcmp(d3dEnv, "true") == 0) {
// printf("Java2D Direct3D usage forced on by J2D_D3D env\n");
d3dEnabled = TRUE;
d3dSet = TRUE;
SetD3DEnabledFlag(env, d3dEnabled, d3dSet);
}
}
}
useD3D = d3dEnabled;
forceD3DUsage = d3dSet;
g_offscreenSharing = GetStaticBoolean(env, wFlagsClass,
"offscreenSharingEnabled");
accelReset = GetStaticBoolean(env, wFlagsClass, "accelReset");
checkRegistry = GetStaticBoolean(env, wFlagsClass, "checkRegistry");
disableRegistry = GetStaticBoolean(env, wFlagsClass, "disableRegistry");
jstring javaVersionString = (jstring)GetStaticObject(env, wFlagsClass,
"javaVersion",
"Ljava/lang/String;");
setHighDPIAware =
(IS_WINVISTA && GetStaticBoolean(env, wFlagsClass, "setHighDPIAware"));
J2dTraceLn(J2D_TRACE_INFO, "WindowsFlags (native):");
J2dTraceLn1(J2D_TRACE_INFO, " d3dEnabled = %s",
(useD3D ? "true" : "false"));
J2dTraceLn1(J2D_TRACE_INFO, " d3dSet = %s",
(forceD3DUsage ? "true" : "false"));
J2dTraceLn1(J2D_TRACE_INFO, " offscreenSharing = %s",
(g_offscreenSharing ? "true" : "false"));
J2dTraceLn1(J2D_TRACE_INFO, " accelReset = %s",
(accelReset ? "true" : "false"));
J2dTraceLn1(J2D_TRACE_INFO, " checkRegistry = %s",
(checkRegistry ? "true" : "false"));
J2dTraceLn1(J2D_TRACE_INFO, " disableRegistry = %s",
(disableRegistry ? "true" : "false"));
J2dTraceLn1(J2D_TRACE_INFO, " setHighDPIAware = %s",
(setHighDPIAware ? "true" : "false"));
}
void
D3DResource::Init(IDirect3DResource9 *pRes, IDirect3DSwapChain9 *pSC)
{
J2dTraceLn(J2D_TRACE_INFO, "D3DResource::Init");
pResource = NULL;
pSwapChain = pSC;
pSurface = NULL;
pTexture = NULL;
pOps = NULL;
ZeroMemory(&desc, sizeof(desc));
desc.Format = D3DFMT_UNKNOWN;
if (pRes != NULL) {
pResource = pRes;
D3DRESOURCETYPE type = pResource->GetType();
switch (type) {
case D3DRTYPE_TEXTURE:
// addRef is needed because both pResource and pTexture will be
// Release()d, and they point to the same object
pResource->AddRef();
pTexture = (IDirect3DTexture9*)pResource;
pTexture->GetSurfaceLevel(0, &pSurface);
break;
case D3DRTYPE_SURFACE:
pResource->AddRef();
pSurface = (IDirect3DSurface9*)pResource;
break;
case D3DRTYPE_CUBETEXTURE:
((IDirect3DCubeTexture9*)pResource)->GetLevelDesc(0, &desc);
break;
default:
J2dTraceLn1(J2D_TRACE_VERBOSE, " resource type=%d", type);
}
} else if (pSwapChain != NULL) {
pSwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pSurface);
} else {
J2dTraceLn(J2D_TRACE_VERBOSE, " pResource == pSwapChain == NULL");
}
if (pSurface != NULL) {
pSurface->GetDesc(&desc);
}
SAFE_PRINTLN(pResource);
SAFE_PRINTLN(pSurface);
SAFE_PRINTLN(pTexture);
SAFE_PRINTLN(pSwapChain);
}
/**
* Decreases the reference count of the array. If the refCount goes to 0,
* then there are no more references to the array and all of the
* array elements, the array itself, and this object can be destroyed.
*
* Returns the number of references left after it was decremented.
*/
int Devices::Release()
{
J2dTraceLn(J2D_TRACE_INFO, "Devices::Release");
CriticalSection::Lock l(arrayLock);
int refs = --refCount;
J2dTraceLn1(J2D_TRACE_VERBOSE, " refCount=%d", refs);
if (refs == 0) {
J2dTraceLn(J2D_TRACE_VERBOSE, " disposing the array");
if (devices != NULL) {
for (int i = 0; i < numDevices; ++i) {
if (devices[i] != NULL) {
delete devices[i];
devices[i] = NULL;
}
}
free(devices);
// null out data, can help with debugging
devices = NULL;
}
// it's safe to delete the instance and only
// then release the static lock
delete this;
// for safety return immediately after committing suicide
// (note: can not reference refCount here!)
return refs;
} else if (refs < 0) {
J2dTraceLn1(J2D_TRACE_ERROR,
"Devices::Release: Negative ref count! refCount=%d",
refs);
}
return refs;
}