/*

 * Copyright 2005-2006 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

#include "sun_java2d_d3d_D3DContext.h"

#include "jlong.h"

#include "jni_util.h"

#include "Trace.h"

#include "ddrawUtils.h"

#include "awt_Win32GraphicsDevice.h"

#include "sun_java2d_SunGraphics2D.h"

#include "GraphicsPrimitiveMgr.h"

#include "RegistryKey.h"

#include "WindowsFlags.h"

#include "Win32SurfaceData.h"

#include "D3DSurfaceData.h"

#include "D3DUtils.h"

#include "D3DContext.h"

#include "D3DRuntimeTest.h"

#include "IntDcm.h"

#include "IntArgb.h"

#include "Region.h"

typedef struct {

    D3DBLEND src;

    D3DBLEND dst;

} D3DBlendRule;

/**

 * This table contains the standard blending rules (or Porter-Duff compositing

 * factors) used in SetRenderState(), indexed by the rule constants from the

 * AlphaComposite class.

 */

D3DBlendRule StdBlendRules[] = {

    { D3DBLEND_ZERO,         D3DBLEND_ZERO        }, /* 0 - Nothing      */

    { D3DBLEND_ZERO,         D3DBLEND_ZERO        }, /* 1 - RULE_Clear   */

    { D3DBLEND_ONE,          D3DBLEND_ZERO        }, /* 2 - RULE_Src     */

    { D3DBLEND_ONE,          D3DBLEND_INVSRCALPHA }, /* 3 - RULE_SrcOver */

    { D3DBLEND_INVDESTALPHA, D3DBLEND_ONE         }, /* 4 - RULE_DstOver */

    { D3DBLEND_DESTALPHA,    D3DBLEND_ZERO        }, /* 5 - RULE_SrcIn   */

    { D3DBLEND_ZERO,         D3DBLEND_SRCALPHA    }, /* 6 - RULE_DstIn   */

    { D3DBLEND_INVDESTALPHA, D3DBLEND_ZERO        }, /* 7 - RULE_SrcOut  */

    { D3DBLEND_ZERO,         D3DBLEND_INVSRCALPHA }, /* 8 - RULE_DstOut  */

    { D3DBLEND_ZERO,         D3DBLEND_ONE         }, /* 9 - RULE_Dst     */

    { D3DBLEND_DESTALPHA,    D3DBLEND_INVSRCALPHA }, /*10 - RULE_SrcAtop */

    { D3DBLEND_INVDESTALPHA, D3DBLEND_SRCALPHA    }, /*11 - RULE_DstAtop */

    { D3DBLEND_INVDESTALPHA, D3DBLEND_INVSRCALPHA }, /*12 - RULE_AlphaXor*/

};

/**

 * D3DContext

 */

D3DContext* D3DContext::CreateD3DContext(DDraw *ddObject, DXObject* dxObject)

{

    J2dTraceLn(J2D_TRACE_INFO, "D3DContext::CreateD3DContext");

    // create and test the d3d context

    D3DContext *d3dContext = new D3DContext(ddObject, dxObject);

    // if there was a failure while creating or testing the device,

    // dispose of it and return NULL

    if (!(d3dContext->GetDeviceCaps() & J2D_D3D_ENABLED_OK)) {

        delete d3dContext;

        d3dContext = NULL;

    }

    return d3dContext;

}

D3DContext::D3DContext(DDraw *ddObject, DXObject* dxObject)

{

    GetExclusiveAccess();

    J2dRlsTraceLn(J2D_TRACE_INFO, "D3DContext::D3DContext");

    J2dTraceLn2(J2D_TRACE_VERBOSE, "  ddObject=0x%d dxObject=0x%x",

                ddObject, dxObject);

    d3dDevice = NULL;

    d3dObject = NULL;

    ddTargetSurface = NULL;

    lpMaskTexture = NULL;

    lpGlyphCacheTexture = NULL;

    glyphCache = NULL;

    glyphCacheAvailable = TRUE;

    deviceCaps = J2D_D3D_FAILURE;

    bBeginScenePending = FALSE;

    jD3DContext = NULL;

    this->dxObject = dxObject;

    this->ddObject = ddObject;

    if (SUCCEEDED(dxObject->CreateD3DObject(&d3dObject))) {

        // The device type we choose to use doesn't change over time

        pDeviceGUID = D3DUtils_SelectDeviceGUID(d3dObject);

        if (pDeviceGUID) {

            bIsHWRasterizer = (*pDeviceGUID == IID_IDirect3DHALDevice ||

                               *pDeviceGUID == IID_IDirect3DTnLHalDevice);

            CreateD3DDevice();

        } else {

            J2dRlsTraceLn(J2D_TRACE_ERROR,

                          "D3CCoD3DContext::D3DContext: Can't find "\

                          "suitable D3D device");

        }

    } else {

        J2dRlsTraceLn(J2D_TRACE_ERROR,

                      "D3DContext::D3DContext: Can't "\

                      "create IDirect3D7 interface");

    }

    compState = sun_java2d_SunGraphics2D_COMP_ISCOPY;

    extraAlpha = 1.0f;

    colorPixel = 0xffffffff;

    ReleaseExclusiveAccess();

}

void D3DContext::SetJavaContext(JNIEnv *env, jobject newD3Dc) {

    GetExclusiveAccess();

    // Only bother if the new D3DContext object is different

    // from the one we already have reference to.

    if (env->IsSameObject(newD3Dc, jD3DContext) == FALSE) {

        J2dTraceLn(J2D_TRACE_VERBOSE, "D3DContext:SetJavaContext: "\

                   "setting new java context object");

        // invalidate the old context, since we've got a new one

        InvalidateIfTarget(env, ddTargetSurface);

        if (jD3DContext != NULL) {

            env->DeleteWeakGlobalRef(jD3DContext);

        }

        // set the new java-level context object

        jD3DContext = env->NewWeakGlobalRef(newD3Dc);

    }

    ReleaseExclusiveAccess();

}

void D3DContext::Release3DDevice() {

    GetExclusiveAccess();

    J2dTraceLn1(J2D_TRACE_INFO,

                "D3DContext::Release3DDevice: d3dDevice = 0x%x",

                d3dDevice);

    // make sure we do EndScene if one is pending

    FlushD3DQueueForTarget(ddTargetSurface);

    // Let the java-level object know that the context

    // state is no longer valid, forcing it to be reinitialized

    // later.

    JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

    InvalidateIfTarget(env, ddTargetSurface);

    // We don't need to release it since we didn't create it

    ddTargetSurface = NULL;

    // disable the use of this context until we ensure the capabilities

    // of the new device and run the tests

    deviceCaps = J2D_D3D_FAILURE;

    if (lpMaskTexture != NULL) {

        lpMaskTexture->Release();

        delete lpMaskTexture;

        lpMaskTexture = NULL;

    }

    // reset the depth buffer format

    memset(&depthBufferFormat, 0, sizeof(depthBufferFormat));

    if (d3dDevice) {

        // setting the texture increases its reference number, so

        // we should reset the textures for all stages to make sure

        // they're released

        for (int stage = 0; stage <= MAX_USED_TEXTURE_STAGE; stage++) {

            d3dDevice->SetTexture(stage, NULL);

            lastTexture[stage] = NULL;

        }

        d3dDevice->Release();

        d3dDevice = NULL;

    }

    ReleaseExclusiveAccess();

}

D3DContext::~D3DContext() {

    J2dTraceLn2(J2D_TRACE_INFO,

                "~D3DContext: d3dDevice=0x%x, d3dObject =0x%x",

                d3dDevice, d3dObject);

    GetExclusiveAccess();

    if (lpGlyphCacheTexture != NULL) {

        lpGlyphCacheTexture->Release();

        delete lpGlyphCacheTexture;

        lpGlyphCacheTexture = NULL;

    }

    Release3DDevice();

    if (d3dObject != NULL) {

        d3dObject->Release();

        d3dObject = NULL;

    }

    ReleaseExclusiveAccess();

}

HRESULT

D3DContext::InitD3DDevice(IDirect3DDevice7 *d3dDevice)

{

    HRESULT res = D3D_OK;

    J2dRlsTraceLn1(J2D_TRACE_INFO,

                   "D3DContext::InitD3DDevice: d3dDevice=Ox%x", d3dDevice);

    d3dDevice->GetCaps(&d3dDevDesc);

    // disable some of the unneeded and costly d3d functionality

    d3dDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, D3DCULL_NONE);

    d3dDevice->SetRenderState(D3DRENDERSTATE_TEXTUREPERSPECTIVE, FALSE);

    d3dDevice->SetRenderState(D3DRENDERSTATE_SPECULARENABLE, FALSE);

    d3dDevice->SetRenderState(D3DRENDERSTATE_LIGHTING,  FALSE);

    d3dDevice->SetRenderState(D3DRENDERSTATE_CLIPPING,  FALSE);

    d3dDevice->SetRenderState(D3DRENDERSTATE_ZENABLE, D3DZB_FALSE);

    d3dDevice->SetRenderState(D3DRENDERSTATE_COLORVERTEX, FALSE);

    d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILENABLE, FALSE);

    d3dDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTFG_POINT);

    d3dDevice->SetTextureStageState(0, D3DTSS_MINFILTER, D3DTFG_POINT);

    // these states never change

    d3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);

    d3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);

    d3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);

    d3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);

    // init the array of latest textures

    memset(&lastTexture, 0, sizeof(lastTexture));

    // this will force the state initialization on first UpdateState

    opState = STATE_UNDEFINED;

    D3DMATRIX tx;

    D3DUtils_SetIdentityMatrix(&tx);

    d3dDevice->SetTransform(D3DTRANSFORMSTATE_WORLD, &tx);

    bBeginScenePending = FALSE;

    D3DUtils_SetupTextureFormats(d3dDevice, textureTable);

    // REMIND: debugging: allows testing the argb path in

    // UploadImageToTexture on devices with alpha texture support

    if ((getenv("J2D_D3D_NOALPHATEXTURE") != NULL) ||

         FAILED(res = D3DUtils_FindMaskTileTextureFormat(d3dDevice,

                                                         &maskTileTexFormat)))

    {

        // use ARGB if can't find alpha texture (or in case argb

        // was specifically requested)

        J2dTraceLn(J2D_TRACE_VERBOSE,

                   "D3DContext::InitD3DDevice: "\

                   "Using IntARBG instead of Alpha texture");

        if (textureTable[TR_TRANSLUCENT_IDX][DEPTH32_IDX].pfType != PF_INVALID)

        {

            memcpy(&maskTileTexFormat,

                   &textureTable[TR_TRANSLUCENT_IDX][DEPTH32_IDX].pddpf,

                   sizeof(maskTileTexFormat));

            res = D3D_OK;

        }

    } else {

        J2dTraceLn(J2D_TRACE_VERBOSE,

                   "D3DContext::InitD3DDevice: Found Alpha-texture format");

    }

    return res;

}

HRESULT

D3DContext::CreateAndTestD3DDevice(DxCapabilities *dxCaps)

{

    J2dRlsTraceLn(J2D_TRACE_INFO, "D3DContext::CreateAndTestD3DDevice");

    HRESULT res;

    if (pDeviceGUID == NULL) {

        J2dRlsTraceLn(J2D_TRACE_ERROR,

                      "D3DContext::CreateAndTestD3DDevice: "\

                      "No usable d3d device");

        deviceCaps = J2D_D3D_FAILURE;

        return DDERR_GENERIC;

    }

    Release3DDevice();

    // Create a temp surface so we can use it when creating a device

    DXSurface *target = NULL;

    if (FAILED(res = CreateSurface(NULL, 10, 10, 32, TR_OPAQUE,

                                   D3D_PLAIN_SURFACE|D3D_RENDER_TARGET,

                                   &target, NULL)))

    {

        DebugPrintDirectDrawError(res,

                                  "D3DContext::CreateAndTestD3DDevice: "\

                                  "can't create scratch surface");

        return res;

    }

    if (FAILED(res = d3dObject->CreateDevice(*pDeviceGUID,

                                             target->GetDDSurface(),

                                             &d3dDevice)))

    {

        DebugPrintDirectDrawError(res,

                                  "D3DContext::CreateAndTestD3DDevice: "\

                                  "error creating d3d device");

    } else if (FAILED(res = InitD3DDevice(d3dDevice))) {

        DebugPrintDirectDrawError(res,

                                  "D3DContext::CreateAndTestD3DDevice: "\

                                  "error initializing D3D device");

    } else {

        J2dRlsTraceLn(J2D_TRACE_VERBOSE,

                      "D3DContext::CreateAndTestD3DDevice: "\

                      "D3D device creation/initialization successful");

        // the device is successfully created and initialized,

        // now run some tests on it

        deviceCaps = TestD3DDevice(ddObject, this, dxCaps);

    }

    // We can safely dispose the scratch surface here

    if (target != NULL) {

        target->Release();

        delete target;

    }

    return res;

}

void

D3DContext::CreateD3DDevice()

{

    GetExclusiveAccess();

    J2dRlsTraceLn(J2D_TRACE_INFO, "D3DContext::CreateD3DDevice");

    // this is a weird way of getting a handle on the ddInstance

    HMONITOR hMonitor = dxObject->GetHMonitor();

    DxCapabilities *dxCaps =

        AwtWin32GraphicsDevice::GetDxCapsForDevice(hMonitor);

    int d3dCapsValidity = dxCaps->GetD3dCapsValidity();

    // Always run the test unless we crashed doing so the last time.

    // The reasons:

    //   - the user may have disabled d3d acceleration in the display panel

    //     since the last run

    //   - the user may have installed the new drivers, which may cause BSODs

    //   - if the test had failed previously because of quality issues, the

    //     new driver may have fixed the problem, but we'd never know since we

    //     never try again

    //   - user (or developer, rather) may have specified a

    //     different rasterizer via env. variable

    if (d3dCapsValidity != J2D_ACCEL_TESTING) {

        dxCaps->SetD3dCapsValidity(J2D_ACCEL_TESTING);

        // this will create the device, test it and set the

        // deviceCaps

        CreateAndTestD3DDevice(dxCaps);

        dxCaps->SetD3dDeviceCaps(deviceCaps);

        dxCaps->SetD3dCapsValidity(J2D_ACCEL_SUCCESS);

    }

    int requiredResults = forceD3DUsage ?

        J2D_D3D_REQUIRED_RESULTS : J2D_D3D_DESIRED_RESULTS;

#ifdef DEBUG

    J2dTraceLn(J2D_TRACE_VERBOSE, "CreateD3DDevice: requested caps:");

    PrintD3DCaps(requiredResults);

    J2dTraceLn(J2D_TRACE_VERBOSE, " caps supported by the device:");

    PrintD3DCaps(deviceCaps);

    J2dTraceLn(J2D_TRACE_VERBOSE, " missing caps:");

    PrintD3DCaps(requiredResults & ~deviceCaps);

#endif // DEBUG

    if ((deviceCaps & requiredResults) != requiredResults) {

        if (!(deviceCaps & J2D_D3D_HW_OK)) {

            // disable d3d for all devices, because we've encountered

            // known bad hardware. See comment in TestForBadHardware().

            J2dRlsTraceLn(J2D_TRACE_ERROR,

                          "CreateD3DDevice: bad hardware found,"\

                          " disabling d3d for all devices.");

            SetD3DEnabledFlag(NULL, FALSE, FALSE);

        } else {

            J2dRlsTraceLn(J2D_TRACE_ERROR,

                          "CreateD3DDevice: tests FAILED, d3d disabled.");

        }

        // REMIND: the first time the context initialization fails,

        // deviceUseD3D is set to FALSE in DDrawObjectStruct, and because of

        // this we never attempt to initialize it again later.

        // For example, if the app switches to a display mode where

        // d3d is not supported, we disable d3d, but it stays disabled

        // even when the display mode is switched back to a supported one.

        // May be we should disable it only in case of a hard error.

        ddObject->DisableD3D();

        Release3DDevice();

    } else {

        deviceCaps |= J2D_D3D_ENABLED_OK;

        J2dRlsTraceLn1(J2D_TRACE_INFO,

                       "CreateD3DDevice: tests PASSED, "\

                       "d3d enabled (forced: %s).",

                       forceD3DUsage ? "yes" : "no");

    }

    ReleaseExclusiveAccess();

}

HRESULT

D3DContext::SetRenderTarget(DDrawSurface *ddSurface)

{

    static D3DVIEWPORT7 vp = { 0, 0, 0, 0, 0.0f, 1.0f };

    static D3DMATRIX tx;

    BOOL bSetProjectionMatrix = FALSE;

    HRESULT res = DDERR_GENERIC;

    GetExclusiveAccess();

    J2dTraceLn2(J2D_TRACE_INFO,

                "D3DContext::SetRenderTarget: old=0x%x new=0x%x",

                ddTargetSurface, ddSurface);

    ddTargetSurface = NULL;

    DXSurface *dxSurface = NULL;

    if (d3dDevice == NULL || ddSurface == NULL ||

        (dxSurface = ddSurface->GetDXSurface()) == NULL)

    {

        ReleaseExclusiveAccess();

        J2dTraceLn3(J2D_TRACE_WARNING,

                    "D3DContext::SetRenderTarget invalid state:"\

                    "d3dDevice=0x%x ddSurface=0x%x dxSurface=0x%x",

                    d3dDevice, ddSurface, dxSurface);

        return res;

    }

    if (FAILED(res = ddSurface->IsLost())) {

        ReleaseExclusiveAccess();

        DebugPrintDirectDrawError(res, "D3DContext::SetRenderTarget: "\

                                  "target surface (and/or depth buffer) lost");

        return res;

    }

    ForceEndScene();

    if (FAILED(res = d3dDevice->SetRenderTarget(dxSurface->GetDDSurface(), 0)))

    {

        ReleaseExclusiveAccess();

        DebugPrintDirectDrawError(res, "D3DContext::SetRenderTarget: "\

                                  "error setting render target");

        return res;

    }

    int width = dxSurface->GetWidth();

    int height = dxSurface->GetHeight();

    // set the projection matrix if the the dimensions of the new

    // rendertarget are different from the old one.

    if (FAILED(d3dDevice->GetViewport(&vp)) ||

        (int)vp.dwWidth != width  || (int)vp.dwHeight != height)

    {

        bSetProjectionMatrix = TRUE;

    }

    vp.dwX = vp.dwY = 0;

    vp.dwWidth  = width;

    vp.dwHeight = height;

    vp.dvMinZ = 0.0f;

    vp.dvMaxZ = 1.0f;

    if (FAILED(res = d3dDevice->SetViewport(&vp))) {

        DebugPrintDirectDrawError(res, "D3DContext::SetRenderTarget: "\

                                  "error setting viewport");

        ReleaseExclusiveAccess();

        return res;

    }

    if (bSetProjectionMatrix) {

        D3DUtils_SetOrthoMatrixOffCenterLH(&tx, (float)width, (float)height);

        res = d3dDevice->SetTransform(D3DTRANSFORMSTATE_PROJECTION, &tx);

    }

    if (SUCCEEDED(res)) {

        ddTargetSurface = ddSurface;

        J2dTraceLn1(J2D_TRACE_VERBOSE,

                    "D3DContext::SetRenderTarget: succeeded, "\

                    "new target=0x%x", ddTargetSurface);

    } else {

        DebugPrintDirectDrawError(res, "D3DContext::SetRenderTarget: failed");

    }

    ReleaseExclusiveAccess();

    return res;

}

HRESULT

D3DContext::SetTransform(jobject xform,

                         jdouble m00, jdouble m10,

                         jdouble m01, jdouble m11,

                         jdouble m02, jdouble m12)

{

    GetExclusiveAccess();

    J2dTraceLn(J2D_TRACE_INFO, "D3DContext::SetTransform");

    if (d3dDevice == NULL) {

        ReleaseExclusiveAccess();

        return DDERR_GENERIC;

    }

    HRESULT res = D3D_OK;

    D3DMATRIX tx;

    if (xform == NULL) {

        J2dTraceLn(J2D_TRACE_VERBOSE, "  disabling transform");

        D3DUtils_SetIdentityMatrix(&tx);

    } else {

        J2dTraceLn(J2D_TRACE_VERBOSE, "  enabling transform");

        // copy values from AffineTransform object into native matrix array

        memset(&tx, 0, sizeof(D3DMATRIX));

        tx._11 = (float)m00;

        tx._12 = (float)m10;

        tx._21 = (float)m01;

        tx._22 = (float)m11;