{

XMFLOAT3 Pos;

XMFLOAT4 Color;

{

XMMATRIX mWorld;

XMMATRIX mView;

XMMATRIX mProjection;

{

UNREFERENCED_PARAMETER( hPrevInstance );

UNREFERENCED_PARAMETER( lpCmdLine );

if( FAILED( InitWindow( hInstance, nCmdShow ) ) )

return 0;

if( FAILED( InitDevice() ) )

{

CleanupDevice();

return 0;

}

// Main message loop

MSG msg = {0};

while( WM_QUIT != msg.message )

{

if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )

{

TranslateMessage( &msg );

DispatchMessage( &msg );

}

else

{

Render();

}

}

CleanupDevice();

return ( int )msg.wParam;

{

// Register class

WNDCLASSEX wcex;

wcex.cbSize = sizeof( WNDCLASSEX );

wcex.style = CS_HREDRAW | CS_VREDRAW;

wcex.lpfnWndProc = WndProc;

wcex.cbClsExtra = 0;

wcex.cbWndExtra = 0;

wcex.hInstance = hInstance;

wcex.hIcon = LoadIcon( hInstance, ( LPCTSTR )IDI_TUTORIAL1 );

wcex.hCursor = LoadCursor( NULL, IDC_ARROW );

wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1 );

wcex.lpszMenuName = NULL;

wcex.lpszClassName = L"TutorialWindowClass";

wcex.hIconSm = LoadIcon( wcex.hInstance, ( LPCTSTR )IDI_TUTORIAL1 );

if( !RegisterClassEx( &wcex ) )

return E_FAIL;

// Create window

g_hInst = hInstance;

RECT rc = { 0, 0, 640, 480 };

AdjustWindowRect( &rc, WS_OVERLAPPEDWINDOW, FALSE );

g_hWnd = CreateWindow( L"TutorialWindowClass", L"Direct3D 11 Tutorial 4: 3D Spaces", WS_OVERLAPPEDWINDOW,

CW_USEDEFAULT, CW_USEDEFAULT, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, hInstance,

NULL );

if( !g_hWnd )

return E_FAIL;

ShowWindow( g_hWnd, nCmdShow );

return S_OK;

{

HRESULT hr = S_OK;

DWORD dwShaderFlags = D3DCOMPILE_ENABLE_STRICTNESS;

#if defined( DEBUG ) || defined( _DEBUG )

// Set the D3DCOMPILE_DEBUG flag to embed debug information in the shaders.

// Setting this flag improves the shader debugging experience, but still allows

// the shaders to be optimized and to run exactly the way they will run in

// the release configuration of this program.

dwShaderFlags |= D3DCOMPILE_DEBUG;

#endif

ID3DBlob* pErrorBlob;

hr = D3DX11CompileFromFile( szFileName, NULL, NULL, szEntryPoint, szShaderModel,

dwShaderFlags, 0, NULL, ppBlobOut, &pErrorBlob, NULL );

if( FAILED(hr) )

{

if( pErrorBlob != NULL )

OutputDebugStringA( (char*)pErrorBlob->GetBufferPointer() );

if( pErrorBlob ) pErrorBlob->Release();

return hr;

}

if( pErrorBlob ) pErrorBlob->Release();

return S_OK;

{

HRESULT hr = S_OK;

RECT rc;

GetClientRect( g_hWnd, &rc );

UINT width = rc.right - rc.left;

UINT height = rc.bottom - rc.top;

UINT createDeviceFlags = 0;

#ifdef _DEBUG

createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;

#endif

D3D_DRIVER_TYPE driverTypes[] =

{

D3D_DRIVER_TYPE_HARDWARE,

D3D_DRIVER_TYPE_WARP,

D3D_DRIVER_TYPE_REFERENCE,

};

UINT numDriverTypes = ARRAYSIZE( driverTypes );

D3D_FEATURE_LEVEL featureLevels[] =

{

D3D_FEATURE_LEVEL_11_0,

D3D_FEATURE_LEVEL_10_1,

D3D_FEATURE_LEVEL_10_0,

};

UINT numFeatureLevels = ARRAYSIZE( featureLevels );

DXGI_SWAP_CHAIN_DESC sd;

ZeroMemory( &sd, sizeof( sd ) );

sd.BufferCount = 1;

sd.BufferDesc.Width = width;

sd.BufferDesc.Height = height;

sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;

sd.BufferDesc.RefreshRate.Numerator = 60;

sd.BufferDesc.RefreshRate.Denominator = 1;

sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;

sd.OutputWindow = g_hWnd;

sd.SampleDesc.Count = 1;

sd.SampleDesc.Quality = 0;

sd.Windowed = TRUE;

for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ )

{

g_driverType = driverTypes[driverTypeIndex];

hr = D3D11CreateDeviceAndSwapChain( NULL, g_driverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels,

D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext );

if( SUCCEEDED( hr ) )

break;

}

if( FAILED( hr ) )

return hr;

// Create a render target view

ID3D11Texture2D* pBackBuffer = NULL;

hr = g_pSwapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), ( LPVOID* )&pBackBuffer );

if( FAILED( hr ) )

return hr;

hr = g_pd3dDevice->CreateRenderTargetView( pBackBuffer, NULL, &g_pRenderTargetView );

pBackBuffer->Release();

if( FAILED( hr ) )

return hr;

//create z buffer

// Create depth stencil texture

D3D11_TEXTURE2D_DESC descDepth;

ZeroMemory( &descDepth, sizeof(descDepth) );

descDepth.Width = width;

descDepth.Height = height;

descDepth.MipLevels = 1;

descDepth.ArraySize = 1;

descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;

descDepth.SampleDesc.Count = 1;

descDepth.SampleDesc.Quality = 0;

descDepth.Usage = D3D11_USAGE_DEFAULT;

descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL;

descDepth.CPUAccessFlags = 0;

descDepth.MiscFlags = 0;

hr = g_pd3dDevice->CreateTexture2D( &descDepth, NULL, &g_pDepthStencil );

if( FAILED( hr ) )

return hr;

// Create the depth stencil view

D3D11_DEPTH_STENCIL_VIEW_DESC descDSV;

ZeroMemory( &descDSV, sizeof(descDSV) );

descDSV.Format = descDepth.Format;

descDSV.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;

descDSV.Texture2D.MipSlice = 0;

hr = g_pd3dDevice->CreateDepthStencilView( g_pDepthStencil, &descDSV, &g_pDepthStencilView );

if( FAILED( hr ) )

return hr;

g_pImmediateContext->OMSetRenderTargets( 1, &g_pRenderTargetView, g_pDepthStencilView );

// Setup the viewport

D3D11_VIEWPORT vp;

vp.Width = (FLOAT)width;

vp.Height = (FLOAT)height;

vp.MinDepth = 0.0f;

vp.MaxDepth = 1.0f;

vp.TopLeftX = 0;

vp.TopLeftY = 0;

g_pImmediateContext->RSSetViewports( 1, &vp );

// Compile the vertex shader

ID3DBlob* pVSBlob = NULL;

hr = CompileShaderFromFile( L"Tutorial04.fx", "VS", "vs_4_0", &pVSBlob );

if( FAILED( hr ) )

{

MessageBox( NULL,

L"The FX file cannot be compiled. Please run this executable from the directory that contains the FX file.", L"Error", MB_OK );

return hr;

}

// Create the vertex shader

hr = g_pd3dDevice->CreateVertexShader( pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), NULL, &g_pVertexShader );

if( FAILED( hr ) )

{

pVSBlob->Release();

return hr;

}

// Define the input layout

D3D11_INPUT_ELEMENT_DESC layout[] =

{

{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },

{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },

};

UINT numElements = ARRAYSIZE( layout );

// Create the input layout

hr = g_pd3dDevice->CreateInputLayout( layout, numElements, pVSBlob->GetBufferPointer(),

pVSBlob->GetBufferSize(), &g_pVertexLayout );

pVSBlob->Release();

if( FAILED( hr ) )

return hr;

// Set the input layout

g_pImmediateContext->IASetInputLayout( g_pVertexLayout );

// Compile the pixel shader

ID3DBlob* pPSBlob = NULL;

hr = CompileShaderFromFile( L"Tutorial04.fx", "PS", "ps_4_0", &pPSBlob );

if( FAILED( hr ) )

{

MessageBox( NULL,

L"The FX file cannot be compiled. Please run this executable from the directory that contains the FX file.", L"Error", MB_OK );

return hr;

}

// Create the pixel shader

hr = g_pd3dDevice->CreatePixelShader( pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), NULL, &g_pPixelShader );

pPSBlob->Release();

if( FAILED( hr ) )

return hr;

// Create vertex buffer

SimpleVertex vertices[] =

{

{ XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT4( 0.0f, 0.0f, 1.0f, 1.0f ) },

{ XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT4( 0.0f, 1.0f, 0.0f, 1.0f ) },

{ XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT4( 0.0f, 1.0f, 1.0f, 1.0f ) },

{ XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT4( 1.0f, 0.0f, 0.0f, 1.0f ) },

{ XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT4( 1.0f, 0.0f, 1.0f, 1.0f ) },

{ XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT4( 1.0f, 1.0f, 0.0f, 1.0f ) },

{ XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT4( 1.0f, 1.0f, 1.0f, 1.0f ) },

{ XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT4( 0.0f, 0.0f, 0.0f, 1.0f ) },

{ XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT4( 0.0f, 0.0f, 1.0f, 1.0f ) },

{ XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT4( 0.0f, 1.0f, 0.0f, 1.0f ) },

{ XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT4( 0.0f, 1.0f, 1.0f, 1.0f ) },

{ XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT4( 1.0f, 0.0f, 0.0f, 1.0f ) },

{ XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT4( 1.0f, 0.0f, 1.0f, 1.0f ) },

{ XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT4( 1.0f, 1.0f, 0.0f, 1.0f ) },

{ XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT4( 1.0f, 1.0f, 1.0f, 1.0f ) },

{ XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT4( 0.0f, 0.0f, 0.0f, 1.0f ) },

};

D3D11_BUFFER_DESC bd;

ZeroMemory( &bd, sizeof(bd) );

bd.Usage = D3D11_USAGE_DEFAULT;

bd.ByteWidth = sizeof( SimpleVertex ) * 8;

bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;

bd.CPUAccessFlags = 0;

D3D11_SUBRESOURCE_DATA InitData;

ZeroMemory( &InitData, sizeof(InitData) );

InitData.pSysMem = vertices;

hr = g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pVertexBuffer );

if( FAILED( hr ) )

return hr;

// Set vertex buffer

UINT stride = sizeof( SimpleVertex );

UINT offset = 0;

g_pImmediateContext->IASetVertexBuffers( 0, 1, &g_pVertexBuffer, &stride, &offset );

// Create index buffer

WORD indices[] =

{

3,1,0,

2,1,3,

0,5,4,

1,5,0,

3,4,7,

0,4,3,

1,6,5,

2,6,1,

2,7,6,

3,7,2,

6,4,5,

7,4,6,

3,1,0,

2,1,3,

0,5,4,

1,5,0,

3,4,7,

0,4,3,

1,6,5,

2,6,1,

2,7,6,

3,7,2,

6,4,5,

7,4,6,

};

bd.Usage = D3D11_USAGE_DEFAULT;

bd.ByteWidth = sizeof( WORD ) * 72; // 36 vertices needed for 12 triangles in a triangle list

bd.BindFlags = D3D11_BIND_INDEX_BUFFER;

bd.CPUAccessFlags = 0;

InitData.pSysMem = indices;

hr = g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pIndexBuffer );

if( FAILED( hr ) )

return hr;

// Set index buffer

g_pImmediateContext->IASetIndexBuffer( g_pIndexBuffer, DXGI_FORMAT_R16_UINT, 0 );

// Set primitive topology

g_pImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );

// Create the constant buffer

bd.Usage = D3D11_USAGE_DEFAULT;

bd.ByteWidth = sizeof(ConstantBuffer);

bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;

bd.CPUAccessFlags = 0;

hr = g_pd3dDevice->CreateBuffer( &bd, NULL, &g_pConstantBuffer );

if( FAILED( hr ) )

return hr;

// Initialize the world matrix

for (int i=0; i<50; i++)

{

g_meshesTransforms[i] = XMMatrixIdentity();

}

// Initialize the view matrix

XMVECTOR Eye = XMVectorSet( 0.0f, 1.0f, -5.0f, 0.0f );

XMVECTOR At = XMVectorSet( 0.0f, 1.0f, 0.0f, 0.0f );

XMVECTOR Up = XMVectorSet( 0.0f, 1.0f, 0.0f, 0.0f );

g_View = XMMatrixLookAtLH( Eye, At, Up );

// Initialize the projection matrix

g_Projection = XMMatrixPerspectiveFovLH( XM_PIDIV2, width / (FLOAT)height, 0.01f, 100.0f );

return S_OK;

{

if( g_pImmediateContext ) g_pImmediateContext->ClearState();

if( g_pConstantBuffer ) g_pConstantBuffer->Release();

if( g_pVertexBuffer ) g_pVertexBuffer->Release();

if( g_pIndexBuffer ) g_pIndexBuffer->Release();

if( g_pVertexLayout ) g_pVertexLayout->Release();

if( g_pVertexShader ) g_pVertexShader->Release();

if( g_pPixelShader ) g_pPixelShader->Release();

if( g_pRenderTargetView ) g_pRenderTargetView->Release();

if( g_pSwapChain ) g_pSwapChain->Release();

if( g_pImmediateContext ) g_pImmediateContext->Release();

if( g_pd3dDevice ) g_pd3dDevice->Release();

{

PAINTSTRUCT ps;

HDC hdc;

switch( message )

{

case WM_PAINT:

hdc = BeginPaint( hWnd, &ps );

EndPaint( hWnd, &ps );

break;

case WM_DESTROY:

PostQuitMessage( 0 );

break;

default:

return DefWindowProc( hWnd, message, wParam, lParam );

}

return 0;

{

// Update our time

static float t = 0.0f;

if( g_driverType == D3D_DRIVER_TYPE_REFERENCE )

{

t += ( float )XM_PI * 0.0125f;

}

else

{

static DWORD dwTimeStart = 0;

DWORD dwTimeCur = GetTickCount();

if( dwTimeStart == 0 )

dwTimeStart = dwTimeCur;

t = ( dwTimeCur - dwTimeStart ) / 1000.0f;

}

//

// Apply transforms to the meshes

//

g_meshesTransforms[0] = XMMatrixRotationY( t );

g_meshesTransforms[1] = XMMatrixTranslation(

0.3f*t,

0.05f*t,

0.05f*t

);

//

// Clear the back buffer

//

float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; // red,green,blue,alpha

g_pImmediateContext->ClearRenderTargetView( g_pRenderTargetView, ClearColor );

//

// Clear the depth buffer to 1.0 (max depth)

//

g_pImmediateContext->ClearDepthStencilView( g_pDepthStencilView, D3D11_CLEAR_DEPTH, 1.0f, 0 );

int meshesNumber = 2;

int meshesVertex[2][2] = {{36,0},{36,36}};

for (int i=meshesNumber-1; i>=0; i--)

{

//

// Update variables

//

ConstantBuffer cb;

cb.mWorld = XMMatrixTranspose( g_meshesTransforms[i] );

cb.mView = XMMatrixTranspose( g_View );

cb.mProjection = XMMatrixTranspose( g_Projection );

g_pImmediateContext->UpdateSubresource( g_pConstantBuffer, 0, NULL, &cb, 0, 0 );

//

// Renders a triangle

//

g_pImmediateContext->VSSetShader( g_pVertexShader, NULL, 0 );

g_pImmediateContext->VSSetConstantBuffers( 0, 1, &g_pConstantBuffer );

g_pImmediateContext->PSSetShader( g_pPixelShader, NULL, 0 );

g_pImmediateContext->DrawIndexed( meshesVertex[i][0], meshesVertex[i][1], 0 ); // 36 vertices needed for 12 triangles in a triangle list

}

//

// Present our back buffer to our front buffer

//

g_pSwapChain->Present( 0, 0 );