stretchrectcases.cpp

微软的Windows Mobile D3D测试代码.

            OutputDebugString(L"To choose smaller resolution, use one of the /e* command line parameters.\n");
            hr = S_FALSE;
            goto cleanup;
        }

        //
        // If the driver doesn't support textures from the specified pool,
        // return S_FALSE to indicate to the test that it should log a skip.
        //
        if (D3DMPOOL_SYSTEMMEM == ResourcePool &&
            !(Caps.SurfaceCaps & D3DMSURFCAPS_SYSTEXTURE))
        {
            OutputDebugString(L"Device does not support system memory textures.");
            hr = S_FALSE;
            goto cleanup;
        }
        
        if (D3DMPOOL_VIDEOMEM == ResourcePool &&
            !(Caps.SurfaceCaps & D3DMSURFCAPS_VIDTEXTURE))
        {
            OutputDebugString(L"Device does not support video memory textures.");
            hr = S_FALSE;
            goto cleanup;
        }
        
        //
        // Get the format in which to create the texture.
        //
        if (FAILED(hr = GetBestFormat(pDevice, ResourceType, &Format)))
        {
            OutputDebugString(L"No valid surface formats found for texture.\n");
            goto cleanup;
        }

        //
        // Create the texture.
        //
        if (FAILED(hr = pDevice->CreateTexture(dwWidth, dwHeight, 1, 0, Format, ResourcePool, &pTexture)))
        {
            OutputDebugString(L"Could not create texture for destination.\n");
            goto cleanup;
        }

        //
        // Get the unknown pointer for the texture. This will be used to release
        // the texture object when its surface is released in the main test.
        //
        if (FAILED(hr = pTexture->QueryInterface(IID_IUnknown, (void**) ppParentObject)))
        {
            OutputDebugString(L"Could not get unknown interface from texture.\n");
            goto cleanup;
        }

        //
        // Get the surface pointer.
        //
        hr = pTexture->GetSurfaceLevel(0, ppSurface);
        if (FAILED(hr))
        {
            OutputDebugString(L"Could not get surface from texture.\n");
            (*ppParentObject)->Release();
            *ppParentObject = NULL;
            goto cleanup;
        }
    }

cleanup:
    if (pTexture)
        pTexture->Release();
    return hr;
}

HRESULT SetupSourceSurface(
    LPDIRECT3DMOBILESURFACE pSurface,
    DWORD dwTableIndex)
{
    HRESULT hr;
    if (FAILED(hr = SurfaceGradient(pSurface, StretchRectCases[dwTableIndex].pfnGetColors)))
    {
        OutputDebugString(L"Could not fill source surface with gradient");
    }
    return hr;
}   

HRESULT GetStretchRects(
    LPDIRECT3DMOBILESURFACE pSurfaceSource,
    LPDIRECT3DMOBILESURFACE pSurfaceDest,
    DWORD dwIteration,
    DWORD dwTableIndex,
    LPRECT pRectSource,
    LPRECT pRectDest)
{
    HRESULT hr = S_OK;
    DWORD dwTotalIterations = StretchRectCases[dwTableIndex].Iterations;
    D3DMSURFACE_DESC d3dsdSource;
    D3DMSURFACE_DESC d3dsdDest;
    LONG WidthSource;
    LONG HeightSource;
    LONG WidthDest;
    LONG HeightDest;
    LONG WidthDelta;
    LONG HeightDelta;
    
    //
    // S_FALSE tells the test that there are no more stretch rects in this test
    // case.
    //
    if (dwTotalIterations == dwIteration)
    {
        hr = S_FALSE;
        goto cleanup;
    }

    //
    // Get the surface descriptions so we can determine what sizes to use.
    //
    if (FAILED(hr = pSurfaceSource->GetDesc(&d3dsdSource)))
    {
        OutputDebugString(L"Could not get surface description of source.\n");
        goto cleanup;
    }

    if (FAILED(hr = pSurfaceDest->GetDesc(&d3dsdDest)))
    {
        OutputDebugString(L"Could not get surface description of destination.\n");
        goto cleanup;
    }

    // 
    // Fill in our rects with the full surface sizes.
    //
    pRectSource->left = pRectSource->top = 0;
    pRectDest->left = pRectDest->top = 0;
    
    pRectSource->right = d3dsdSource.Width;
    pRectSource->bottom = d3dsdSource.Height;

    pRectDest->right = d3dsdDest.Width;
    pRectDest->bottom = d3dsdDest.Height;

    WidthSource = pRectSource->right - pRectSource->left;
    HeightSource = pRectSource->bottom - pRectSource->top;
    
    WidthDest = pRectDest->right - pRectDest->left;
    HeightDest = pRectDest->bottom - pRectDest->top;

    if (D3DQA_STRETCH == StretchRectCases[dwTableIndex].StretchType)
    {
        // Stretching

        // Use a ninth of the source.
        WidthSource /= 3;
        HeightSource /= 3;

        InflateRect(pRectSource, -WidthSource, -HeightSource);

        // Recalculate to eliminate rounding problems.
        WidthSource = pRectSource->right - pRectSource->left;
        HeightSource = pRectSource->bottom - pRectSource->top;

        // Calculate the amount of room to stretch on each side
        WidthDelta = (WidthDest - WidthSource) / 2;
        HeightDelta = (HeightDest - HeightSource) / 2;

        // Calculate the Dest rect based on the delta and the current iteration
        WidthDelta = WidthDelta * dwIteration / dwTotalIterations;
        HeightDelta = HeightDelta * dwIteration / dwTotalIterations;

        InflateRect(pRectDest, -WidthDelta, -HeightDelta);
    }
    else if (D3DQA_SHRINK == StretchRectCases[dwTableIndex].StretchType)
    {
        // Shrinking

        // Use a ninth of the destination ultimately.
        WidthDest /= 3;
        HeightDest /= 3;

        // Calculate the amount of room to stretch on each side
        WidthDelta = (WidthSource - WidthDest) / 2;
        HeightDelta = (HeightSource - HeightDest) / 2;

        // Calculate the Dest rect based on the delta and the current iteration
        WidthDelta = WidthDelta * dwIteration / dwTotalIterations;
        HeightDelta = HeightDelta * dwIteration / dwTotalIterations;

        InflateRect(pRectDest, -WidthDelta, -HeightDelta);
    }
    else if (D3DQA_COPY == StretchRectCases[dwTableIndex].StretchType)
    {
        RECT rcTemp;
        IntersectRect(&rcTemp, pRectSource, pRectDest);
        CopyRect(pRectSource, &rcTemp);
        CopyRect(pRectDest, &rcTemp);
    }

cleanup:
    return hr;
}

HRESULT GetFilterType(
    LPDIRECT3DMOBILEDEVICE pDevice,
    D3DMTEXTUREFILTERTYPE * d3dtft,
    DWORD dwTableIndex)
{
    D3DMCAPS Caps;

    pDevice->GetDeviceCaps(&Caps);

    *d3dtft = StretchRectCases[dwTableIndex].FilterType;

    //
    // If the driver doesn't support this type of filter with this operation,
    // return S_FALSE to indicate to the test that the test case should log a skip.
    //
    if (D3DMTEXF_LINEAR == *d3dtft &&
        D3DQA_STRETCH == StretchRectCases[dwTableIndex].StretchType &&
        !(Caps.StretchRectFilterCaps & D3DMPTFILTERCAPS_MAGFLINEAR))
    {
        return S_FALSE;
    }
    
    if (D3DMTEXF_LINEAR == *d3dtft &&
        D3DQA_SHRINK == StretchRectCases[dwTableIndex].StretchType &&
        !(Caps.StretchRectFilterCaps & D3DMPTFILTERCAPS_MINFLINEAR))
    {
        return S_FALSE;
    }

    if (D3DMTEXF_POINT == *d3dtft &&
        D3DQA_STRETCH == StretchRectCases[dwTableIndex].StretchType &&
        !(Caps.StretchRectFilterCaps & D3DMPTFILTERCAPS_MAGFPOINT))
    {
        return S_FALSE;
    }
    
    if (D3DMTEXF_POINT == *d3dtft &&
        D3DQA_SHRINK == StretchRectCases[dwTableIndex].StretchType &&
        !(Caps.StretchRectFilterCaps & D3DMPTFILTERCAPS_MINFPOINT))
    {
        return S_FALSE;
    }
    return S_OK;
}

HRESULT GetColorsSquare(
    D3DMFORMAT Format,
    int iX,
    int iY,
    int Width,
    int Height,
    float * prRed,
    float * prGreen,
    float * prBlue,
    float * prAlpha)
{
    HRESULT hr = S_OK;
    LONG WidthSource;
    LONG HeightSource;
    static RECT RectSource = {0, 0, 0, 0};

    if (0 == iX && 0 == iY)
    {
        // 
        // Fill in our rects with the full surface sizes.
        //
        RectSource.left = RectSource.top = 0;

        RectSource.right = Width;
        RectSource.bottom = Height;

        WidthSource = RectSource.right - RectSource.left;
        HeightSource = RectSource.bottom - RectSource.top;

        // Use a ninth of the source.
        WidthSource /= 3;
        HeightSource /= 3;

        InflateRect(&RectSource, -WidthSource, -HeightSource);

        // Recalculate to eliminate rounding problems.
        WidthSource = RectSource.right - RectSource.left;
        HeightSource = RectSource.bottom - RectSource.top;
    }

    if (iX >= RectSource.left && iX < RectSource.right &&
        iY >= RectSource.top && iY < RectSource.bottom)
    {
        *prRed = *prGreen = *prBlue = 1.0;
    }
    else
    {
        *prRed = *prGreen = *prBlue = 0.0;
    }

    *prAlpha = 1.0;

    return hr;
}