/****************************************************************************
 *
 *    File: testd3d8.cpp
 * Project: DxDiag (DirectX Diagnostic Tool)
 *  Author: Jason Sandlin (jasonsa@microsoft.com)
 * Purpose: Test D3D8/AGP Texturing functionality on this machine
 *
 * (C) Copyright 2000 Microsoft Corp.  All rights reserved.
 *
 ****************************************************************************/

#include <Windows.h>
#define DIRECT3D_VERSION 0x0800 // file uses DX8 
#include <d3d8.h>
#include <d3dx8.h>
#include "reginfo.h"
#include "sysinfo.h"
#include "dispinfo.h"
#include "testagp.h"
#include "resource.h"

#ifndef ReleasePpo
    #define ReleasePpo(ppo) \
        if (*(ppo) != NULL) \
        { \
            (*(ppo))->Release(); \
            *(ppo) = NULL; \
        } \
        else (VOID)0
#endif

typedef IDirect3D8* (WINAPI* LPDIRECT3DCREATE8)(UINT SDKVersion);

#define D3DFVF_VERTEX (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_TEX1)

#define MAX_FORMATS             64
#define MAX_MODES               256
#define MAX_CONFIRMED_MODES     256

struct D3DVERTEX
{
    D3DXVECTOR3 p;
    D3DXVECTOR3 n;
    FLOAT       tu, tv;

    D3DVERTEX() {};
    D3DVERTEX( D3DXVECTOR3 vp, D3DXVECTOR3 vn, FLOAT fTu, FLOAT fTv ) : p(vp), n(vn), tu(fTu), tv(fTv) {}
};

struct D3DModeInfo
{
    DWORD      Width;      // Screen width in this mode
    DWORD      Height;     // Screen height in this mode
    D3DFORMAT  Format;     // Pixel format in this mode
    DWORD      dwBehavior; // Hardware / Software / Mixed vertex processing
};

enum TESTID
{
    TESTID_LOAD_D3D8_DLL=1,
    TESTID_GET_D3DCREATE8,
    TESTID_D3DCREATE8,
    TESTID_ENUMADAPTERMODES,
    TESTID_GETDEVICECAPS,
    TESTID_NOMODEFOUND,
    TESTID_CREATE_TEST_WINDOW,
    TESTID_CREATE_DEVICE,
    TESTID_GETBACKBUFFER,
    TESTID_GETDESC,
    TESTID_CREATE_VERTEX_BUFFER,
    TESTID_CREATE_INDEX_BUFFER,
    TESTID_LOCK,
    TESTID_UNLOCK,
    TESTID_SETLIGHT,
    TESTID_LIGHTENABLE,
    TESTID_SETTRANSFORM,
    TESTID_SETRENDERSTATE,
    TESTID_CREATETEXTURE,
    TESTID_SETTEXTURESTAGESTATE,
    TESTID_SETTEXTURE,
    TESTID_SETVERTEXSHADER,
    TESTID_USER_CANCELLED,
    TESTID_VIEWPORT_CLEAR,
    TESTID_BEGINSCENE,
    TESTID_SETMATERIAL,
    TESTID_SETSTREAMSOURCE,
    TESTID_SETINDICES,
    TESTID_DRAW_INDEXED_PRIMITIVE,
    TESTID_ENDSCENE,
    TESTID_PRESENT,
    TESTID_USER_VERIFY_D3D7_RENDERING,
    TESTID_USER_VERIFY_D3D8_RENDERING,
    TESTID_LOAD_DDRAW_DLL,
    TESTID_GET_DIRECTDRAWCREATE,
    TESTID_DIRECTDRAWCREATE,
    TESTID_SETCOOPERATIVELEVEL_FULLSCREEN,
    TESTID_SETCOOPERATIVELEVEL_NORMAL,
    TESTID_SETDISPLAYMODE,
    TESTID_CREATEPRIMARYSURFACE_FLIP_ONEBACK,
    TESTID_GETATTACHEDSURFACE,
    TESTID_QUERY_D3D,
    TESTID_SETVIEWPORT,
    TESTID_ENUMTEXTUREFORMATS,
    TESTID_CREATESURFACE,
    TESTID_GETDC,
    TESTID_RELEASEDC,
};

BOOL BTranslateError(HRESULT hr, TCHAR* psz, BOOL bEnglish = FALSE); // from main.cpp 
static HRESULT SelectModeAndFormat( DisplayInfo* pDisplayInfo, IDirect3D8* pD3D8, D3DModeInfo* pSelectedMode, D3DDEVTYPE* pSelectedDeviceType );
static HRESULT Test3D( BOOL bUseTexture, IDirect3D8* pD3D8, HWND hwndMain, DWORD iAdapter, D3DModeInfo selectedMode, D3DDEVTYPE selectedDeviceType, LONG* piStepThatFailed );
static HRESULT CreateTestWindow(HWND hwndMain, HWND* phwnd);
static HRESULT InitVertexBuffer( IDirect3DDevice8* pd3dDevice, const D3DVERTEX* vertexArray, DWORD dwNumVertices, LPDIRECT3DVERTEXBUFFER8* ppVB, LONG* piStepThatFailed );
static HRESULT InitIndexBuffer( IDirect3DDevice8* pd3dDevice, const WORD* wIndexArray, DWORD dwNumIndices, LPDIRECT3DINDEXBUFFER8* ppIB, LONG* piStepThatFailed );
static HRESULT DrawTwoSides( BOOL bUseTexture, IDirect3DDevice8* pd3dDevice, D3DMATERIAL8* pMtrl, LPDIRECT3DVERTEXBUFFER8 pVB1, LPDIRECT3DINDEXBUFFER8 pIB1, LPDIRECT3DVERTEXBUFFER8 pVB2, LPDIRECT3DINDEXBUFFER8 pIB2, LONG* piStepThatFailed );




//-----------------------------------------------------------------------------
// Name: TestD3Dv8()
// Desc: 
//-----------------------------------------------------------------------------
VOID TestD3Dv8( BOOL bUseTexture, HWND hwndMain, DisplayInfo* pDisplayInfo)
{
    HRESULT             hr             = S_OK;
    TCHAR               sz[MAX_PATH];
    TCHAR               szTitle[MAX_PATH];
    HINSTANCE           hInstD3D8      = NULL;
    IDirect3D8*         pD3D8          = NULL;
    HWND                hwnd           = NULL;
    D3DModeInfo         selectedMode;
    D3DDEVTYPE          selectedDeviceType;
  
    if( pDisplayInfo == NULL )
        return;

    LoadString(NULL, IDS_APPFULLNAME, szTitle, MAX_PATH);

    LPDIRECT3DCREATE8 pD3DCreate8 = NULL;
    TCHAR szPath[MAX_PATH];

    GetSystemDirectory(szPath, MAX_PATH);
    lstrcat(szPath, TEXT("\\d3d8.dll"));

    // This may fail if DX8 isn't on the system
    hInstD3D8 = LoadLibrary(szPath);
    if (hInstD3D8 == NULL)
    {
        pDisplayInfo->m_testResultD3D8.m_iStepThatFailed = TESTID_LOAD_D3D8_DLL;
        pDisplayInfo->m_testResultD3D8.m_hr = E_FAIL;
        goto LEnd;
    }

    pD3DCreate8 = (LPDIRECT3DCREATE8)GetProcAddress(hInstD3D8, "Direct3DCreate8");
    if (pD3DCreate8 == NULL)
    {
        FreeLibrary(hInstD3D8);
        hInstD3D8 = NULL;

        pDisplayInfo->m_testResultD3D8.m_iStepThatFailed = TESTID_GET_D3DCREATE8;
        pDisplayInfo->m_testResultD3D8.m_hr = E_POINTER;
        goto LEnd;
    }

    pD3D8 = pD3DCreate8(D3D_SDK_VERSION);
    if( pD3D8 == NULL )
    {
        // We have the wrong headers since d3d8.dll loaded but D3DCreate8() failed.
        pDisplayInfo->m_testResultD3D8.m_iStepThatFailed = TESTID_D3DCREATE8;
        pDisplayInfo->m_testResultD3D8.m_hr = E_FAIL;
        goto LEnd;
    }

    // Enum and select a support mode and format and device type
    if( FAILED( SelectModeAndFormat( pDisplayInfo, pD3D8, 
                                     &selectedMode, &selectedDeviceType ) ) )
        goto LEnd;

    // Save the cursor
    POINT ptMouse;
    GetCursorPos(&ptMouse);

    // Run the test
    if (FAILED(hr = Test3D( bUseTexture, pD3D8, hwndMain, pDisplayInfo->m_iAdapter, selectedMode, 
                            selectedDeviceType, &pDisplayInfo->m_testResultD3D8.m_iStepThatFailed)))
    {
        pDisplayInfo->m_testResultD3D8.m_hr = hr;
        goto LEnd;
    }

    // Restore the cursor position
    SetCursorPos( ptMouse.x, ptMouse.y );    

    // Tell the user if they canceled
    if (pDisplayInfo->m_testResultD3D8.m_iStepThatFailed == TESTID_USER_CANCELLED)
    {
        LoadString(NULL, IDS_YOUCANCELLED, sz, MAX_PATH);
        MessageBox(hwndMain, sz, szTitle, MB_OK);
        pDisplayInfo->m_testResultD3D8.m_bCancelled = TRUE;
        goto LEnd;
    }

    // Confirm the test succeeded
    LoadString(NULL, IDS_CONFIRMD3DTEST, sz, MAX_PATH);
    if (IDNO == MessageBox(hwndMain, sz, szTitle, MB_YESNO))
    {
        pDisplayInfo->m_testResultD3D8.m_iStepThatFailed = TESTID_USER_VERIFY_D3D8_RENDERING;
        pDisplayInfo->m_testResultD3D8.m_hr = S_OK;
        goto LEnd;
    }

LEnd:
    ReleasePpo( &pD3D8 );
    if( hInstD3D8 )
    {
        FreeLibrary(hInstD3D8);
        hInstD3D8 = NULL;
    }
}




//-----------------------------------------------------------------------------
// Name: Test3D()
// Desc: Generate a spinning 3D cube
//-----------------------------------------------------------------------------
HRESULT Test3D( BOOL bUseTexture, IDirect3D8* pD3D8, HWND hwndMain, DWORD iAdapter, 
                D3DModeInfo selectedMode, D3DDEVTYPE selectedDeviceType, 
                LONG* piStepThatFailed )
{
    LPDIRECT3DDEVICE8       pd3dDevice    = NULL;
    LPDIRECT3DTEXTURE8      pTexture      = NULL;
    LPDIRECT3DVERTEXBUFFER8 pVBFront      = NULL;
    LPDIRECT3DINDEXBUFFER8  pIBFront      = NULL;
    LPDIRECT3DVERTEXBUFFER8 pVBBack       = NULL;
    LPDIRECT3DINDEXBUFFER8  pIBBack       = NULL;
    LPDIRECT3DVERTEXBUFFER8 pVBLeft       = NULL;
    LPDIRECT3DINDEXBUFFER8  pIBLeft       = NULL;
    LPDIRECT3DVERTEXBUFFER8 pVBRight      = NULL;
    LPDIRECT3DINDEXBUFFER8  pIBRight      = NULL;
    LPDIRECT3DVERTEXBUFFER8 pVBTop        = NULL;
    LPDIRECT3DINDEXBUFFER8  pIBTop        = NULL;
    LPDIRECT3DVERTEXBUFFER8 pVBBottom     = NULL;
    LPDIRECT3DINDEXBUFFER8  pIBBottom     = NULL;
    LPDIRECT3DSURFACE8      pBackBuffer   = NULL;   
    D3DMATERIAL8            mtrlWhite;
    D3DMATERIAL8            mtrlRed;
    D3DMATERIAL8            mtrlBlue;
    D3DMATERIAL8            mtrlGreen;
    D3DXMATRIX              matRotY;
    D3DXMATRIX              matRotX;
    D3DXMATRIX              mat;
    D3DSURFACE_DESC         d3dsdBackBuffer;   
    FLOAT                   fRotY;
    FLOAT                   fRotX;
    HRESULT                 hr;
    HWND                    hwnd;
    MSG                     msg;
    DWORD                   i;

    static const D3DVERTEX vertexArrayFront[] = 
    {
        D3DVERTEX(D3DXVECTOR3(-1.0, -1.0, -1.0), D3DXVECTOR3(0.0, 0.0, -1.0),   1.0f, 0.0f),
        D3DVERTEX(D3DXVECTOR3( 1.0, -1.0, -1.0), D3DXVECTOR3(0.0, 0.0, -1.0),   0.0f, 0.0f),
        D3DVERTEX(D3DXVECTOR3(-1.0,  1.0, -1.0), D3DXVECTOR3(0.0, 0.0, -1.0),   1.0f, 1.0f),
        D3DVERTEX(D3DXVECTOR3( 1.0,  1.0, -1.0), D3DXVECTOR3(0.0, 0.0, -1.0),   0.0f, 1.0f),
    };
    static const WORD indexArrayFront[] = 
    {
        0, 2, 1,
        2, 3, 1,
    };

    static const D3DVERTEX vertexArrayBack[] = 
    {
        D3DVERTEX(D3DXVECTOR3(-1.0, -1.0, 1.0),  D3DXVECTOR3(0.0, 0.0, 1.0),   0.0f, 0.0f),
        D3DVERTEX(D3DXVECTOR3( 1.0, -1.0, 1.0),  D3DXVECTOR3(0.0, 0.0, 1.0),   1.0f, 0.0f),
        D3DVERTEX(D3DXVECTOR3(-1.0,  1.0, 1.0),  D3DXVECTOR3(0.0, 0.0, 1.0),   0.0f, 1.0f),
        D3DVERTEX(D3DXVECTOR3( 1.0,  1.0, 1.0),  D3DXVECTOR3(0.0, 0.0, 1.0),   1.0f, 1.0f),
    };
    static const WORD indexArrayBack[] = 
    {
        0, 1, 2,
        2, 1, 3,
    };

    static const D3DVERTEX vertexArrayLeft[] = 
    {
        D3DVERTEX(D3DXVECTOR3(-1.0, -1.0, -1.0),  D3DXVECTOR3(-1.0, 0.0, 0.0),   0.0f, 0.0f),
        D3DVERTEX(D3DXVECTOR3(-1.0, -1.0,  1.0),  D3DXVECTOR3(-1.0, 0.0, 0.0),   1.0f, 0.0f),
        D3DVERTEX(D3DXVECTOR3(-1.0,  1.0, -1.0),  D3DXVECTOR3(-1.0, 0.0, 0.0),   0.0f, 1.0f),
        D3DVERTEX(D3DXVECTOR3(-1.0,  1.0,  1.0),  D3DXVECTOR3(-1.0, 0.0, 0.0),   1.0f, 1.0f),
    };
    static const WORD indexArrayLeft[] = 
    {
        0, 1, 2,
        2, 1, 3,
    };

    static const D3DVERTEX vertexArrayRight[] = 
    {
        D3DVERTEX(D3DXVECTOR3(1.0, -1.0, -1.0),  D3DXVECTOR3(1.0, 0.0, 0.0),   1.0f, 0.0f),
        D3DVERTEX(D3DXVECTOR3(1.0, -1.0,  1.0),  D3DXVECTOR3(1.0, 0.0, 0.0),   0.0f, 0.0f),
        D3DVERTEX(D3DXVECTOR3(1.0,  1.0, -1.0),  D3DXVECTOR3(1.0, 0.0, 0.0),   1.0f, 1.0f),
        D3DVERTEX(D3DXVECTOR3(1.0,  1.0,  1.0),  D3DXVECTOR3(1.0, 0.0, 0.0),   0.0f, 1.0f),
    };
    static const WORD indexArrayRight[] = 
    {
        0, 2, 1,
        2, 3, 1,
    };

    static const D3DVERTEX vertexArrayTop[] = 
    {
        D3DVERTEX(D3DXVECTOR3(-1.0, 1.0, -1.0),  D3DXVECTOR3(0.0, 1.0, 0.0),   0.0f, 1.0f),
        D3DVERTEX(D3DXVECTOR3( 1.0, 1.0, -1.0),  D3DXVECTOR3(0.0, 1.0, 0.0),   1.0f, 1.0f),
        D3DVERTEX(D3DXVECTOR3(-1.0, 1.0,  1.0),  D3DXVECTOR3(0.0, 1.0, 0.0),   0.0f, 0.0f),
        D3DVERTEX(D3DXVECTOR3( 1.0, 1.0,  1.0),  D3DXVECTOR3(0.0, 1.0, 0.0),   1.0f, 0.0f),
    };
    static const WORD indexArrayTop[] = 
    {
        0, 2, 1,
        2, 3, 1,
    };

    static const D3DVERTEX vertexArrayBottom[] = 
    {
        D3DVERTEX(D3DXVECTOR3(-1.0, -1.0, -1.0),  D3DXVECTOR3(0.0, -1.0, 0.0),   1.0f, 1.0f),
        D3DVERTEX(D3DXVECTOR3( 1.0, -1.0, -1.0),  D3DXVECTOR3(0.0, -1.0, 0.0),   0.0f, 1.0f),
        D3DVERTEX(D3DXVECTOR3(-1.0, -1.0,  1.0),  D3DXVECTOR3(0.0, -1.0, 0.0),   1.0f, 0.0f),
        D3DVERTEX(D3DXVECTOR3( 1.0, -1.0,  1.0),  D3DXVECTOR3(0.0, -1.0, 0.0),   0.0f, 0.0f),
    };
    static const WORD indexArrayBottom[] = 
    {
        0, 1, 2,
        2, 1, 3,
    };

    ShowCursor(FALSE);
    // Create test window
    if (FAILED(hr = CreateTestWindow(hwndMain, &hwnd)))
    {
        *piStepThatFailed = TESTID_CREATE_TEST_WINDOW;
        goto LEnd;
    }

    // Set up the presentation parameters
    D3DPRESENT_PARAMETERS d3dpp;         
    ZeroMemory( &d3dpp, sizeof(d3dpp) );
    d3dpp.Windowed                          = FALSE;
    d3dpp.BackBufferCount                   = 1;
    d3dpp.MultiSampleType                   = D3DMULTISAMPLE_NONE;
    d3dpp.SwapEffect                        = D3DSWAPEFFECT_DISCARD;
    d3dpp.EnableAutoDepthStencil            = FALSE;
    d3dpp.FullScreen_RefreshRateInHz        = D3DPRESENT_RATE_DEFAULT;
    d3dpp.FullScreen_PresentationInterval   = D3DPRESENT_INTERVAL_ONE;
    d3dpp.hDeviceWindow                     = hwnd;
    d3dpp.BackBufferWidth                   = selectedMode.Width;
    d3dpp.BackBufferHeight                  = selectedMode.Height;
    d3dpp.BackBufferFormat                  = selectedMode.Format;

    // Create the device
    if( FAILED( hr = pD3D8->CreateDevice( iAdapter, selectedDeviceType,
                                          hwnd, selectedMode.dwBehavior, &d3dpp,
                                          &pd3dDevice ) ) )
    {
        *piStepThatFailed  = TESTID_CREATE_DEVICE;
        goto LEnd;
    }
    if( pd3dDevice == NULL )
    {
        *piStepThatFailed  = TESTID_CREATE_DEVICE;
        hr = E_POINTER;
        goto LEnd;
    }

    // Get the desc of the backbuffer
    if( FAILED( hr = pd3dDevice->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer ) ) )
    {
        *piStepThatFailed  = TESTID_GETBACKBUFFER;
        goto LEnd;
    }
    if( pBackBuffer == NULL )
    {
        *piStepThatFailed  = TESTID_GETBACKBUFFER;
        hr = E_POINTER;
        goto LEnd;
    }

    if( FAILED( hr = pBackBuffer->GetDesc( &d3dsdBackBuffer ) ) )
    {
        *piStepThatFailed  = TESTID_GETDESC;
        goto LEnd;
    }
    ReleasePpo(&pBackBuffer);

    // Init the vertex/index buffer for the Front 
    if( FAILED( hr = InitVertexBuffer( pd3dDevice, vertexArrayFront, sizeof(vertexArrayFront)/sizeof(D3DVERTEX), &pVBFront, piStepThatFailed ) ) )
        goto LEnd;
    if( FAILED( hr = InitIndexBuffer( pd3dDevice, indexArrayFront, sizeof(indexArrayFront)/sizeof(WORD), &pIBFront, piStepThatFailed ) ) )
        goto LEnd;

    // Init the vertex/index buffer for the Back
    if( FAILED( hr = InitVertexBuffer( pd3dDevice, vertexArrayBack, sizeof(vertexArrayBack)/sizeof(D3DVERTEX), &pVBBack, piStepThatFailed ) ) )
        goto LEnd;
    if( FAILED( hr = InitIndexBuffer( pd3dDevice, indexArrayBack, sizeof(indexArrayBack)/sizeof(WORD), &pIBBack, piStepThatFailed ) ) )
        goto LEnd;

    // Init the vertex/index buffer for the Left
    if( FAILED( hr = InitVertexBuffer( pd3dDevice, vertexArrayLeft, sizeof(vertexArrayLeft)/sizeof(D3DVERTEX), &pVBLeft, piStepThatFailed ) ) )
        goto LEnd;
    if( FAILED( hr = InitIndexBuffer( pd3dDevice, indexArrayLeft, sizeof(indexArrayLeft)/sizeof(WORD), &pIBLeft, piStepThatFailed ) ) )
        goto LEnd;

    // Init the vertex/index buffer for the Right
    if( FAILED( hr = InitVertexBuffer( pd3dDevice, vertexArrayRight, sizeof(vertexArrayRight)/sizeof(D3DVERTEX), &pVBRight, piStepThatFailed ) ) )
        goto LEnd;
    if( FAILED( hr = InitIndexBuffer( pd3dDevice, indexArrayRight, sizeof(indexArrayRight)/sizeof(WORD), &pIBRight, piStepThatFailed ) ) )
        goto LEnd;

    // Init the vertex/index buffer for the Top
    if( FAILED( hr = InitVertexBuffer( pd3dDevice, vertexArrayTop, sizeof(vertexArrayTop)/sizeof(D3DVERTEX), &pVBTop, piStepThatFailed ) ) )
        goto LEnd;
    if( FAILED( hr = InitIndexBuffer( pd3dDevice, indexArrayTop, sizeof(indexArrayTop)/sizeof(WORD), &pIBTop, piStepThatFailed ) ) )
        goto LEnd;
    
    // Init the vertex/index buffer for the Bottom
    if( FAILED( hr = InitVertexBuffer( pd3dDevice, vertexArrayBottom, sizeof(vertexArrayBottom)/sizeof(D3DVERTEX), &pVBBottom, piStepThatFailed ) ) )
        goto LEnd;
    if( FAILED( hr = InitIndexBuffer( pd3dDevice, indexArrayBottom, sizeof(indexArrayBottom)/sizeof(WORD), &pIBBottom, piStepThatFailed ) ) )
        goto LEnd;

    // Add a light
    D3DLIGHT8 light;
    ZeroMemory( &light, sizeof(D3DLIGHT8) );
    light.Type        = D3DLIGHT_DIRECTIONAL;
    light.Diffuse.r   = 1.0f;
    light.Diffuse.g   = 1.0f;
    light.Diffuse.b   = 1.0f;
    light.Direction.x = 0.0f;
    light.Direction.y = 0.0f;
    light.Direction.z = 1.0f;

    if( FAILED( hr = pd3dDevice->SetLight( 0, &light ) ) )
    {
        *piStepThatFailed = TESTID_SETLIGHT;
        goto LEnd;
    }
    if( FAILED( hr = pd3dDevice->LightEnable( 0, TRUE ) ) )
    {
        *piStepThatFailed = TESTID_LIGHTENABLE; 
        goto LEnd;
    }

    // Set up matrices
    mat = D3DXMATRIX(1.0f, 0.0f, 0.0f, 0.0f,
                     0.0f, 1.0f, 0.0f, 0.0f,
                     0.0f, 0.0f, 1.0f, 0.0f,
                     0.0f, 0.0f, 0.0f, 1.0f);
    if( FAILED( hr = pd3dDevice->SetTransform( D3DTS_WORLD, &mat ) ) )
    {
        *piStepThatFailed = TESTID_SETTRANSFORM;
        goto LEnd;
    }

    mat = D3DXMATRIX(1.0f, 0.0f, 0.0f, 0.0f,
                     0.0f, 1.0f, 0.0f, 0.0f,
                     0.0f, 0.0f, 1.0f, 0.0f,
                     0.0f, 0.0f, 5.0f, 1.0f);
    if( FAILED( hr = pd3dDevice->SetTransform( D3DTS_VIEW, &mat ) ) )
    {
        *piStepThatFailed = TESTID_SETTRANSFORM;
        goto LEnd;
    }

    D3DXMatrixPerspectiveFovLH( &mat, D3DXToRadian(60.0f), 
                                (float) d3dsdBackBuffer.Width / (float) d3dsdBackBuffer.Height, 
                                1.0f, 1000.0f );
    if( FAILED( hr = pd3dDevice->SetTransform( D3DTS_PROJECTION, &mat ) ) )
    {
        *piStepThatFailed = TESTID_SETTRANSFORM;
        goto LEnd;
    }

    fRotY = 3.14f;
    fRotX = 0.0f;

    if( FAILED( hr = pd3dDevice->SetRenderState( D3DRS_DITHERENABLE, TRUE ) ) )
    {
        *piStepThatFailed = TESTID_SETRENDERSTATE;
        goto LEnd;
    }
    if( FAILED( hr = pd3dDevice->SetRenderState( D3DRS_AMBIENT, 0x40404040 ) ) )
    {
        *piStepThatFailed = TESTID_SETRENDERSTATE; 
        goto LEnd;
    }

    ZeroMemory( &mtrlWhite, sizeof(D3DMATERIAL8) );
    mtrlWhite.Diffuse.r = mtrlWhite.Ambient.r = 1.0f;
    mtrlWhite.Diffuse.g = mtrlWhite.Ambient.g = 1.0f;
    mtrlWhite.Diffuse.b = mtrlWhite.Ambient.b = 1.0f;
    mtrlWhite.Diffuse.a = mtrlWhite.Ambient.a = 0.0f;

    ZeroMemory( &mtrlRed, sizeof(D3DMATERIAL8) );
    mtrlRed.Diffuse.r = mtrlRed.Ambient.r = 1.0f;
    mtrlRed.Diffuse.g = mtrlRed.Ambient.g = 0.0f;
    mtrlRed.Diffuse.b = mtrlRed.Ambient.b = 0.0f;
    mtrlRed.Diffuse.a = mtrlRed.Ambient.a = 0.0f;

    ZeroMemory( &mtrlGreen, sizeof(D3DMATERIAL8) );
    mtrlGreen.Diffuse.r = mtrlGreen.Ambient.r = 0.0f;
    mtrlGreen.Diffuse.g = mtrlGreen.Ambient.g = 1.0f;
    mtrlGreen.Diffuse.b = mtrlGreen.Ambient.b = 0.0f;
    mtrlGreen.Diffuse.a = mtrlGreen.Ambient.a = 0.0f;

    ZeroMemory( &mtrlBlue, sizeof(D3DMATERIAL8) );
    mtrlBlue.Diffuse.r = mtrlBlue.Ambient.r = 0.0f;
    mtrlBlue.Diffuse.g = mtrlBlue.Ambient.g = 0.0f;
    mtrlBlue.Diffuse.b = mtrlBlue.Ambient.b = 1.0f;
    mtrlBlue.Diffuse.a = mtrlBlue.Ambient.a = 0.0f;

    if( bUseTexture )
    {
        D3DCAPS8 d3dCaps;         

        // Load default texture in resource anDefaultTextureResource[i]
        if( FAILED( hr = D3DXCreateTextureFromResourceEx( pd3dDevice, NULL, TEXT("DIRECTX"), 
                                D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, d3dsdBackBuffer.Format, 
                                D3DPOOL_DEFAULT, D3DX_FILTER_TRIANGLE|D3DX_FILTER_MIRROR, 
                                D3DX_FILTER_TRIANGLE|D3DX_FILTER_MIRROR, 0, NULL, NULL, &pTexture ) ) )
        {
            *piStepThatFailed  = TESTID_CREATETEXTURE;
            goto LEnd;
        }

        if( FAILED( hr = pd3dDevice->GetDeviceCaps( &d3dCaps ) ) )
        {
            *piStepThatFailed  = TESTID_GETDEVICECAPS;
            goto LEnd;
        }

        if( d3dCaps.TextureFilterCaps & D3DPTFILTERCAPS_MINFLINEAR )
        {
            if (FAILED(hr = pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR )))
            {
                *piStepThatFailed = TESTID_SETTEXTURESTAGESTATE; 
                goto LEnd;
            }
	    }
    
        if( d3dCaps.TextureFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR )
        {
            if (FAILED(hr = pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR )))
            {
                *piStepThatFailed = TESTID_SETTEXTURESTAGESTATE; 
                goto LEnd;
            }
        }

        if (FAILED( hr = pd3dDevice->SetTexture( 0, pTexture ) ) )
        {
            *piStepThatFailed = TESTID_SETTEXTURE; 
            goto LEnd;
        }

        if (FAILED(hr = pd3dDevice->SetTextureStageState( 0, D3DTSS_ADDRESSU,  D3DTADDRESS_CLAMP ) ) )
        {
            *piStepThatFailed = TESTID_SETTEXTURESTAGESTATE; 
            goto LEnd;
        }

        if (FAILED(hr = pd3dDevice->SetTextureStageState( 0, D3DTSS_ADDRESSV,  D3DTADDRESS_CLAMP ) ) )
        {
            *piStepThatFailed = TESTID_SETTEXTURESTAGESTATE; 
            goto LEnd;
        }

        if (FAILED(hr = pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE ) ) )
        {
            *piStepThatFailed = TESTID_SETTEXTURESTAGESTATE; 
            goto LEnd;
        }

        if (FAILED(hr = pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE ) ) )
        {
            *piStepThatFailed = TESTID_SETTEXTURESTAGESTATE; 
            goto LEnd;
        }

        if (FAILED(hr = pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE ) ) )
        {
            *piStepThatFailed = TESTID_SETTEXTURESTAGESTATE; 
            goto LEnd;
        }

        // Set color
        if( FAILED( hr = pd3dDevice->SetMaterial( &mtrlWhite ) ) )
        {
            *piStepThatFailed = TESTID_SETMATERIAL; 
            goto LEnd;
        }
    }

    if( FAILED( hr = pd3dDevice->SetVertexShader( D3DFVF_VERTEX ) ) )
    {
        *piStepThatFailed = TESTID_SETVERTEXSHADER; 
        goto LEnd;
    }

    // Here's the draw loop:
    for (i = 0; i < 600; i++)
    {
        if (PeekMessage(&msg, hwnd, WM_KEYDOWN, WM_KEYDOWN, PM_REMOVE))
        {
            *piStepThatFailed = TESTID_USER_CANCELLED;
            goto LEnd;
        }

        if( FAILED( hr = pd3dDevice->TestCooperativeLevel() ) )
        {
            *piStepThatFailed = TESTID_USER_CANCELLED;
            goto LEnd;
        }

        // Build world matrix
        D3DXMatrixRotationY( &matRotY, fRotY );
        D3DXMatrixRotationX( &matRotX, fRotX );
        D3DXMatrixMultiply( &mat, &matRotY, &matRotX );

        if( FAILED( hr = pd3dDevice->SetTransform( D3DTS_WORLD, &mat ) ) )
        {
            *piStepThatFailed = TESTID_SETTRANSFORM;
            goto LEnd;
        }

        // Clear the backbuffer
        if (FAILED(hr = pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET,
                                           0x00000000, 1.0f, 0L )))
        {
            *piStepThatFailed = TESTID_VIEWPORT_CLEAR;
            goto LEnd;
        }

        // Begin the scene
        if( FAILED(hr = pd3dDevice->BeginScene() ) )
        {
            *piStepThatFailed = TESTID_BEGINSCENE;
            goto LEnd;
        }

        // Green, Front/Back
        if( FAILED( hr = DrawTwoSides( bUseTexture, pd3dDevice, &mtrlGreen, 
                                       pVBFront, pIBFront, pVBBack, pIBBack, 
                                       piStepThatFailed ) ) ) 
            goto LEnd;


        // Red, Left/Right
        if( FAILED( hr = DrawTwoSides( bUseTexture, pd3dDevice, &mtrlRed, 
                                       pVBLeft, pIBLeft, pVBRight, pIBRight, 
                                       piStepThatFailed ) ) ) 
            goto LEnd;

        // Blue, Top/Bottom
        if( FAILED( hr = DrawTwoSides( bUseTexture, pd3dDevice, &mtrlBlue, 
                                       pVBTop, pIBTop, pVBBottom, pIBBottom, 
                                       piStepThatFailed ) ) ) 
            goto LEnd;

        // End the scene.
        if (FAILED(hr = pd3dDevice->EndScene()))
        {
            *piStepThatFailed = TESTID_ENDSCENE;
            goto LEnd;
        }

        if (FAILED(hr = pd3dDevice->Present( NULL, NULL, NULL, NULL ) ) )
        {
            *piStepThatFailed = TESTID_PRESENT;
            goto LEnd;
        }

        fRotY += 0.05f;
        fRotX += 0.02f;

        Sleep(10);
    }

LEnd:
    ShowCursor(TRUE);
    ReleasePpo(&pTexture);
    ReleasePpo(&pVBFront);
    ReleasePpo(&pIBFront);
    ReleasePpo(&pVBBack);
    ReleasePpo(&pIBBack);
    ReleasePpo(&pVBLeft);
    ReleasePpo(&pIBLeft);
    ReleasePpo(&pVBRight);
    ReleasePpo(&pIBRight);
    ReleasePpo(&pVBTop);
    ReleasePpo(&pIBTop);
    ReleasePpo(&pVBBottom);
    ReleasePpo(&pIBBottom);
    ReleasePpo(&pBackBuffer);
    ReleasePpo(&pd3dDevice);
    if (hwnd != NULL)
        SendMessage(hwnd, WM_CLOSE, 0, 0);

    return hr;
}




//-----------------------------------------------------------------------------
// Name: CreateTestWindow()
// Desc: 
//-----------------------------------------------------------------------------
HRESULT CreateTestWindow(HWND hwndMain, HWND* phwnd)
{
    static BOOL bClassRegistered = FALSE;
    WNDCLASS wndClass;
    TCHAR* pszClass = TEXT("DxDiag D3D8 Test Window"); // Don't need to localize
    HINSTANCE hInst = (HINSTANCE)GetWindowLongPtr(hwndMain, GWLP_HINSTANCE);
    TCHAR szTitle[MAX_PATH];

    if (!bClassRegistered)
    {
        ZeroMemory(&wndClass, sizeof(wndClass));
        wndClass.style = CS_HREDRAW | CS_VREDRAW;
        wndClass.lpfnWndProc = DefWindowProc;
        wndClass.cbClsExtra = 0;
        wndClass.cbWndExtra = 0;
        wndClass.hInstance = hInst;
        wndClass.hIcon = NULL;
        wndClass.hCursor = NULL;
        wndClass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
        wndClass.lpszMenuName = NULL;
        wndClass.lpszClassName = pszClass;
        if (NULL == RegisterClass(&wndClass))
            return E_FAIL;
        bClassRegistered = TRUE;
    }

    LoadString(NULL, IDS_APPFULLNAME, szTitle, MAX_PATH);
    *phwnd = CreateWindow( pszClass, szTitle, WS_OVERLAPPED, 
                           0, 0, 0, 0, hwndMain, NULL, hInst, NULL);
    if (*phwnd == NULL)
        return E_FAIL;

    ShowWindow(*phwnd, SW_SHOW);

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: SortModesCallback()
// Desc: Callback function for sorting display modes (used by BuildDeviceList).
//-----------------------------------------------------------------------------
static int SortModesCallback( const VOID* arg1, const VOID* arg2 )
{
    D3DDISPLAYMODE* p1 = (D3DDISPLAYMODE*)arg1;
    D3DDISPLAYMODE* p2 = (D3DDISPLAYMODE*)arg2;

    if( p1->Format > p2->Format )   return -1;
    if( p1->Format < p2->Format )   return +1;
    if( p1->Width  < p2->Width )    return -1;
    if( p1->Width  > p2->Width )    return +1;
    if( p1->Height < p2->Height )   return -1;
    if( p1->Height > p2->Height )   return +1;

    return 0;
}




//-----------------------------------------------------------------------------
// Name: SelectModeAndFormat()
// Desc: 
//-----------------------------------------------------------------------------
HRESULT SelectModeAndFormat( DisplayInfo* pDisplayInfo, IDirect3D8* pD3D8, 
                             D3DModeInfo* pSelectedMode, D3DDEVTYPE* pSelectedDeviceType )
{
    // Enumerate all display modes on this adapter
    HRESULT        hr;
    D3DDISPLAYMODE modes[MAX_MODES];
    D3DFORMAT      formats[MAX_FORMATS];
    DWORD          dwBehavior[MAX_FORMATS];
    D3DModeInfo    confirmedModes[MAX_CONFIRMED_MODES];   

    ZeroMemory( pSelectedMode, sizeof(D3DModeInfo) );

    DWORD dwNumConfirmedModes   = 0;   
    DWORD dwNumFormats          = 0;
    DWORD dwNumModes            = 0;
    DWORD dwNumAdapterModes     = pD3D8->GetAdapterModeCount( pDisplayInfo->m_iAdapter );
    DWORD dwBestMatchMode       = 0;

    for( UINT iMode = 0; iMode < dwNumAdapterModes; iMode++ )
    {
        // Get the display mode attributes
        D3DDISPLAYMODE DisplayMode;
        if( FAILED( hr = pD3D8->EnumAdapterModes( pDisplayInfo->m_iAdapter, iMode, &DisplayMode ) ) )
        {
            pDisplayInfo->m_testResultD3D8.m_iStepThatFailed = TESTID_ENUMADAPTERMODES;
            pDisplayInfo->m_testResultD3D8.m_hr = hr;
            return hr;
        }

        // Check if the mode already exists (to filter out refresh rates)
        for( DWORD m=0L; m<dwNumModes; m++ )
        {
            if( ( modes[m].Width  == DisplayMode.Width  ) &&
                ( modes[m].Height == DisplayMode.Height ) &&
                ( modes[m].Format == DisplayMode.Format ) )
                break;
        }

        // If we found a new mode, add it to the list of modes
        if( m == dwNumModes )
        {
            modes[dwNumModes].Width       = DisplayMode.Width;
            modes[dwNumModes].Height      = DisplayMode.Height;
            modes[dwNumModes].Format      = DisplayMode.Format;
            modes[dwNumModes].RefreshRate = 0;
            dwNumModes++;

            // Check if the mode's format already exists
            for( DWORD f=0; f<dwNumFormats; f++ )
            {
                if( DisplayMode.Format == formats[f] )
                    break;
            }

            // If the format is new, add it to the list
            if( f== dwNumFormats )
                formats[dwNumFormats++] = DisplayMode.Format;
        }

        if( dwNumFormats == MAX_FORMATS || dwNumModes == MAX_MODES )
            break;
    }

    // Sort the list of display modes (by format, then width, then height)
    qsort( modes, dwNumModes, sizeof(D3DDISPLAYMODE), SortModesCallback );

    const DWORD dwNumDeviceTypes = 2;
    const D3DDEVTYPE DeviceTypes[] = { D3DDEVTYPE_HAL, D3DDEVTYPE_SW };

    // Add devices to adapter
    for( UINT iDevice = 0; iDevice < dwNumDeviceTypes; iDevice++ )
    {
        // Fill in device info
        D3DCAPS8 d3dCaps;         
        if( FAILED( hr = pD3D8->GetDeviceCaps( pDisplayInfo->m_iAdapter, DeviceTypes[iDevice], &d3dCaps ) ) )
        {
            pDisplayInfo->m_testResultD3D8.m_iStepThatFailed = TESTID_GETDEVICECAPS;
            pDisplayInfo->m_testResultD3D8.m_hr = hr;
            return hr;
        }

        // Examine each format supported by the adapter 
        for( DWORD f=0; f<dwNumFormats; f++ )
        {
            // Skip formats that cannot be used as render targets on this device
            if( FAILED( pD3D8->CheckDeviceType( pDisplayInfo->m_iAdapter, DeviceTypes[iDevice],
                                                formats[f], formats[f], FALSE ) ) )
                continue;

            // Figure out the behavior
            if( d3dCaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT )
            {
                if( d3dCaps.DevCaps & D3DDEVCAPS_PUREDEVICE )
                {
                    dwBehavior[f] = D3DCREATE_HARDWARE_VERTEXPROCESSING |
                                    D3DCREATE_PUREDEVICE;
                }
                else
                {
                    dwBehavior[f] = D3DCREATE_HARDWARE_VERTEXPROCESSING;
                }
            }
            else
            {
                dwBehavior[f] = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
            }
        }

        // Add all enumerated display modes with confirmed formats to the
        // device's list of valid modes
        for( DWORD m=0L; m<dwNumModes; m++ )
        {
            for( DWORD f=0; f<dwNumFormats; f++ )
            {
                if( modes[m].Format == formats[f] )
                {
                    // Add this mode to the device's list of valid modes
                    confirmedModes[dwNumConfirmedModes].Width      = modes[m].Width;
                    confirmedModes[dwNumConfirmedModes].Height     = modes[m].Height;
                    confirmedModes[dwNumConfirmedModes].Format     = modes[m].Format;
                    confirmedModes[dwNumConfirmedModes].dwBehavior = dwBehavior[f];
                    dwNumConfirmedModes++;
                }
            }
        }

        // Select any 640x480 mode for default (but prefer a 16-bit mode)
        for( m=0; m<dwNumConfirmedModes; m++ )
        {
            if( confirmedModes[m].Width==640 && confirmedModes[m].Height==480 )
            {
                dwBestMatchMode = m;
                if( confirmedModes[m].Format == D3DFMT_R5G6B5 ||
                    confirmedModes[m].Format == D3DFMT_X1R5G5B5 ||
                    confirmedModes[m].Format == D3DFMT_A1R5G5B5 )
                {
                    break;
                }
            }
        }

        // If valid modes were found then stop and use this device
        if( dwNumConfirmedModes > 0 )
            break;
    }

    if( dwNumConfirmedModes > 0 )
    {
        *pSelectedDeviceType = DeviceTypes[iDevice];
        *pSelectedMode = confirmedModes[dwBestMatchMode];
        return S_OK;
    }
    else
    {
        pDisplayInfo->m_testResultD3D8.m_iStepThatFailed = TESTID_NOMODEFOUND;
        pDisplayInfo->m_testResultD3D8.m_hr = E_FAIL;
        return E_FAIL;
    }
}




//-----------------------------------------------------------------------------
// Name: InitVertexBuffer()
// Desc: 
//-----------------------------------------------------------------------------
HRESULT InitVertexBuffer( IDirect3DDevice8* pd3dDevice, const D3DVERTEX* vertexArray, 
                          DWORD dwNumVertices, LPDIRECT3DVERTEXBUFFER8* ppVB, 
                          LONG* piStepThatFailed )
{
    HRESULT hr = S_OK;
    DWORD   i;
    D3DVERTEX* vVertex = NULL;

    if( FAILED( hr = pd3dDevice->CreateVertexBuffer( dwNumVertices*sizeof(D3DVERTEX),
                                                  D3DUSAGE_WRITEONLY, D3DFVF_VERTEX,
                                                  D3DPOOL_MANAGED, ppVB ) ) )
    {
        *piStepThatFailed  = TESTID_CREATE_VERTEX_BUFFER;
        goto LEnd;
    }
    if( *ppVB == NULL )
    {
        *piStepThatFailed  = TESTID_CREATE_VERTEX_BUFFER;
        hr = E_POINTER;
        goto LEnd;
    }

    if( FAILED( hr = (*ppVB)->Lock( 0, 0, (BYTE**)&vVertex, 0 ) ) )
    {
        *piStepThatFailed  = TESTID_LOCK;
        goto LEnd;
    }
    if( vVertex == NULL )
    {
        *piStepThatFailed  = TESTID_LOCK;
        goto LEnd;
    }

    for( i=0; i<dwNumVertices; i++ )
        vVertex[i] = vertexArray[i];

    if( FAILED( hr = (*ppVB)->Unlock() ) )
    {
        *piStepThatFailed = TESTID_UNLOCK;
        goto LEnd;
    }

LEnd:
    return hr;
}




//-----------------------------------------------------------------------------
// Name: InitIndexBuffer()
// Desc: 
//-----------------------------------------------------------------------------
HRESULT InitIndexBuffer( IDirect3DDevice8* pd3dDevice, const WORD* wIndexArray, 
                         DWORD dwNumIndices, LPDIRECT3DINDEXBUFFER8* ppIB, 
                         LONG* piStepThatFailed )
{
    HRESULT hr = S_OK;
    DWORD   i;
    WORD*   pwIndices = NULL;

    if( FAILED( hr = pd3dDevice->CreateIndexBuffer( dwNumIndices*sizeof(WORD),
                                                    D3DUSAGE_WRITEONLY, D3DFMT_INDEX16,
                                                    D3DPOOL_MANAGED, ppIB ) ) )
    {
        *piStepThatFailed  = TESTID_CREATE_INDEX_BUFFER;
        goto LEnd;
    }
    if( *ppIB == NULL )
    {
        *piStepThatFailed  = TESTID_CREATE_INDEX_BUFFER;
        hr = E_POINTER;
        goto LEnd;
    }

    if( FAILED( hr = (*ppIB)->Lock( 0, dwNumIndices*sizeof(WORD), (BYTE**) &pwIndices, 0 ) ) )
    {
        *piStepThatFailed  = TESTID_LOCK;
        goto LEnd;
    }
    if( pwIndices == NULL )
    {
        *piStepThatFailed  = TESTID_LOCK;
        goto LEnd;
    }

    for( i=0; i<dwNumIndices; i++ )
        *pwIndices++ = wIndexArray[i];

    if( FAILED( hr = (*ppIB)->Unlock() ) )
    {
        *piStepThatFailed = TESTID_UNLOCK;
        goto LEnd;
    }

LEnd:
    return hr;
}




//-----------------------------------------------------------------------------
// Name: DrawTwoSides()
// Desc: 
//-----------------------------------------------------------------------------
HRESULT DrawTwoSides( BOOL bUseTexture, IDirect3DDevice8* pd3dDevice, D3DMATERIAL8* pMtrl, 
                      LPDIRECT3DVERTEXBUFFER8 pVB1, LPDIRECT3DINDEXBUFFER8 pIB1, 
                      LPDIRECT3DVERTEXBUFFER8 pVB2, LPDIRECT3DINDEXBUFFER8 pIB2, 
                      LONG* piStepThatFailed )
{   
    HRESULT hr;

    if( !bUseTexture )
    {
        // Set color
        if( FAILED( hr = pd3dDevice->SetMaterial( pMtrl ) ) )
        {
            *piStepThatFailed = TESTID_SETMATERIAL; 
            goto LEnd;
        }
    }

    // #1
    if( FAILED( hr = pd3dDevice->SetStreamSource( 0, pVB1, sizeof(D3DVERTEX) ) ) )
    {
        *piStepThatFailed = TESTID_SETSTREAMSOURCE; 
        goto LEnd;
    }

    if( FAILED( hr = pd3dDevice->SetIndices( pIB1, 0 ) ) )
    {
        *piStepThatFailed = TESTID_SETINDICES; 
        goto LEnd;
    }

    if( FAILED( hr = pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 4, 0, 2 ) ) )
    {
        *piStepThatFailed = TESTID_DRAW_INDEXED_PRIMITIVE; 
        goto LEnd;
    }

    // #2
    if( FAILED( hr = pd3dDevice->SetStreamSource( 0, pVB2, sizeof(D3DVERTEX) ) ) ) 
    {
        *piStepThatFailed = TESTID_SETSTREAMSOURCE; 
        goto LEnd;
    }

    if( FAILED( hr = pd3dDevice->SetIndices( pIB2, 0 ) ) )
    {
        *piStepThatFailed = TESTID_SETINDICES; 
        goto LEnd;
    }

    if( FAILED( hr = pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 4, 0, 2 ) ) )
    {
        *piStepThatFailed = TESTID_DRAW_INDEXED_PRIMITIVE; 
        goto LEnd;
    }

LEnd:
    return hr;
}