//--------------------------------------------------------------------------------------
// Direct3Dデバイスとスワップチェーン
//--------------------------------------------------------------------------------------
HRESULT InitDevice()
{
HRESULT hr = S_OK;
UINT createDeviceFlags = 0;
//ドライバタイプの定義
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,
D3D_FEATURE_LEVEL_9_3,
D3D_FEATURE_LEVEL_9_2,
D3D_FEATURE_LEVEL_9_1
};
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;
//Direct3Dデバイスの作成とスワップチェーンの作成
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;
//レンダーターゲットビュー
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;
//深度バッファ作成（ステンシル）
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;
//ステンシルビューの作成
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 );
//ビューポートの設定
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 );
//頂点シェーダーをコンパイル
ID3DBlob* pVSBlob = NULL;
hr = CompileShaderFromFile( "SimpleShader.hlsl", "VS", "vs_4_0", &pVSBlob );
if( FAILED( hr ) )
{
MessageBox( NULL,"頂点シェーダーを読み込めませんでした。", "Error", MB_OK );
return hr;
}
//頂点シェーダーから頂点シェーダのオブジェクトを作成
hr = g_pd3dDevice->CreateVertexShader( pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), NULL, &g_pVertexShader );
if( FAILED( hr ) )
{
pVSBlob->Release();
return hr;
}
//頂点のインプットレイアウトを定義
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 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 28, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = ARRAYSIZE( layout );
//インプットレイアウトの作成
hr = g_pd3dDevice->CreateInputLayout( layout, numElements, pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(), &g_pVertexLayout );
pVSBlob->Release();pVSBlob = NULL;
if( FAILED( hr ) )
return hr;
//インプットレイアウトのセット
g_pImmediateContext->IASetInputLayout( g_pVertexLayout );
//ピクセルシェーダーをコンパイル
ID3DBlob* pPSBlob = NULL;
hr = CompileShaderFromFile("SimpleShader.hlsl", "PS", "ps_4_0", &pPSBlob );
if( FAILED( hr ) )
{
MessageBox( NULL,"頂点シェーダーを読み込めませんでした。", "Error", MB_OK );
return hr;
}
//ピクセルシェーダーからピクセルシェーダのオブジェクトを作成
hr = g_pd3dDevice->CreatePixelShader( pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), NULL, &g_pPixelShader );
pPSBlob->Release();
if( FAILED( hr ) )
return hr;
//頂点バッファの作成
SimpleVertex vertices[] =
{
{ XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT4( 1.0f, 0.0f, 0.0f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
{ XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT4( 1.0f, 1.0f, 0.0f, 1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
{ XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT4( 0.0f, 1.0f, 0.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
{ XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT4( 1.0f, 1.0f, 0.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },
{ XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT4( 1.0f, 1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
{ XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT4( 1.0f, 1.0f, 1.0f, 1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
{ XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT4( 1.0f, 1.0f, 1.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
{ XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT4( 1.0f, 1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },
{ XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT4( 0.0f, 0.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
{ XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT4( 0.0f, 1.0f, 1.0f, 1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
{ XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT4( 0.0f, 1.0f, 0.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
{ XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT4( 0.0f, 1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },
{ XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT4( 0.5f, 0.5f, 0.5f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
{ XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT4( 0.5f, 0.5f, 0.5f, 1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
{ XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT4( 0.5f, 0.5f, 0.5f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
{ XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT4( 0.5f, 0.5f, 0.5f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },
{ XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT4( 1.0f, 1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
{ XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT4( 1.0f, 1.0f, 1.0f, 1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
{ XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT4( 1.0f, 1.0f, 1.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
{ XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT4( 1.0f, 1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },
{ XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT4( 1.0f, 0.0f, 0.0f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
{ XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT4( 0.0f, 1.0f, 0.0f, 1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
{ XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT4( 0.0f, 0.0f, 1.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
{ XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT4( 0.0f, 0.0f, 0.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },
};
D3D11_BUFFER_DESC bd;
ZeroMemory( &bd, sizeof(bd) );
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( SimpleVertex ) * 24;
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;
//インデックスバッファの作成
WORD indices[] =
{
3,1,0,
2,1,3,
6,4,5,
7,4,6,
11,9,8,
10,9,11,
14,12,13,
15,12,14,
19,17,16,
18,17,19,
22,20,21,
23,20,22
};
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( WORD ) * 36; // 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;
// コンスタントバッファの作成
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;
//画像をテクスチャにロード
hr = D3DX11CreateShaderResourceViewFromFile( g_pd3dDevice, "suwako.png", NULL, NULL, &g_pTextureRV, NULL );
if( FAILED( hr ) )
return hr;
//サンプラーステートの作成
D3D11_SAMPLER_DESC sampDesc;
ZeroMemory( &sampDesc, sizeof(sampDesc) );
sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
sampDesc.MinLOD = 0;
sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
hr = g_pd3dDevice->CreateSamplerState( &sampDesc, &g_pSamplerLinear );
if( FAILED( hr ) )
return hr;
//行列の設定
// ワールド行列は単位行列
g_World = XMMatrixIdentity();
//ビュー行列の定義
XMVECTOR Eye = XMVectorSet( 0.0f, 1.0f, -5.0f, 0.0f ); //カメラの位置
XMVECTOR At = XMVectorSet( 0.0f, 0.0f, 0.0f, 0.0f ); //カメラの注視先
XMVECTOR Up = XMVectorSet( 0.0f, 1.0f, 0.0f, 0.0f ); //カメラの真上のベクトル
g_View = XMMatrixLookAtLH( Eye, At, Up );
//プロジェクション行列
g_Projection = XMMatrixPerspectiveFovLH( XM_PIDIV2, WIDTH / (FLOAT)HEIGHT, 0.01f, 100.0f );
InitOculusRiftObjects();
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create Direct3D device and swap chain
//--------------------------------------------------------------------------------------
HRESULT InitDevice()
{
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 = 1;
sd.BufferDesc.RefreshRate.Denominator = 60;
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 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"Tutorial07.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_pCubeVertexShader );
if( FAILED( hr ) )
{
pVSBlob->Release();
return hr;
}
// Create the input layout
D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "INSTANCE_POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 0, D3D11_INPUT_PER_INSTANCE_DATA, 1 },
{ "INSTANCE_SCALE", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 16, D3D11_INPUT_PER_INSTANCE_DATA, 1 },
{ "INSTANCE_COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 32, D3D11_INPUT_PER_INSTANCE_DATA, 1 },
};
UINT numElements = ARRAYSIZE( layout );
hr = g_pd3dDevice->CreateInputLayout( layout, numElements, pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(), &g_pCubeVertexLayout );
pVSBlob->Release();
if( FAILED( hr ) )
return hr;
}
{
// Compile the pixel shader
ID3DBlob* pPSBlob = NULL;
hr = CompileShaderFromFile( L"Tutorial07.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_pCubePixelShader );
pPSBlob->Release();
if( FAILED( hr ) )
return hr;
}
// Create vertex buffer
{
SimpleVertex vertices[] =
{
{ XMFLOAT3(-1.0f, 1.0f,-1.0f), XMFLOAT3( 0.0f, 1.0f, 0.0f) },
{ XMFLOAT3( 1.0f, 1.0f,-1.0f), XMFLOAT3( 0.0f, 1.0f, 0.0f) },
{ XMFLOAT3( 1.0f, 1.0f, 1.0f), XMFLOAT3( 0.0f, 1.0f, 0.0f) },
{ XMFLOAT3(-1.0f, 1.0f, 1.0f), XMFLOAT3( 0.0f, 1.0f, 0.0f) },
{ XMFLOAT3(-1.0f,-1.0f,-1.0f), XMFLOAT3( 0.0f,-1.0f, 0.0f) },
{ XMFLOAT3( 1.0f,-1.0f,-1.0f), XMFLOAT3( 0.0f,-1.0f, 0.0f) },
{ XMFLOAT3( 1.0f,-1.0f, 1.0f), XMFLOAT3( 0.0f,-1.0f, 0.0f) },
{ XMFLOAT3(-1.0f,-1.0f, 1.0f), XMFLOAT3( 0.0f,-1.0f, 0.0f) },
{ XMFLOAT3(-1.0f,-1.0f, 1.0f), XMFLOAT3(-1.0f, 0.0f, 0.0f) },
{ XMFLOAT3(-1.0f,-1.0f,-1.0f), XMFLOAT3(-1.0f, 0.0f, 0.0f) },
{ XMFLOAT3(-1.0f, 1.0f,-1.0f), XMFLOAT3(-1.0f, 0.0f, 0.0f) },
{ XMFLOAT3(-1.0f, 1.0f, 1.0f), XMFLOAT3(-1.0f, 0.0f, 0.0f) },
{ XMFLOAT3( 1.0f,-1.0f, 1.0f), XMFLOAT3( 1.0f, 0.0f, 0.0f) },
{ XMFLOAT3( 1.0f,-1.0f,-1.0f), XMFLOAT3( 1.0f, 0.0f, 0.0f) },
{ XMFLOAT3( 1.0f, 1.0f,-1.0f), XMFLOAT3( 1.0f, 0.0f, 0.0f) },
{ XMFLOAT3( 1.0f, 1.0f, 1.0f), XMFLOAT3( 1.0f, 0.0f, 0.0f) },
{ XMFLOAT3(-1.0f,-1.0f,-1.0f), XMFLOAT3( 0.0f, 0.0f,-1.0f ) },
{ XMFLOAT3( 1.0f,-1.0f,-1.0f), XMFLOAT3( 0.0f, 0.0f,-1.0f ) },
{ XMFLOAT3( 1.0f, 1.0f,-1.0f), XMFLOAT3( 0.0f, 0.0f,-1.0f ) },
{ XMFLOAT3(-1.0f, 1.0f,-1.0f), XMFLOAT3( 0.0f, 0.0f,-1.0f ) },
{ XMFLOAT3(-1.0f,-1.0f, 1.0f), XMFLOAT3( 0.0f, 0.0f, 1.0f ) },
{ XMFLOAT3( 1.0f,-1.0f, 1.0f), XMFLOAT3( 0.0f, 0.0f, 1.0f ) },
{ XMFLOAT3( 1.0f, 1.0f, 1.0f), XMFLOAT3( 0.0f, 0.0f, 1.0f ) },
{ XMFLOAT3(-1.0f, 1.0f, 1.0f), XMFLOAT3( 0.0f, 0.0f, 1.0f ) },
};
g_pCubeVertexBuffer = CreateVertexBuffer(vertices, sizeof(SimpleVertex)*ARRAYSIZE(vertices));
}
{
g_pCubeInstanceBuffer = CreateVertexBuffer(g_sphgrid.particles, sizeof(sphParticle) * SPH_MAX_PARTICLE_NUM);
}
// Create index buffer
{
WORD indices[] =
{
3,1,0, 2,1,3,
6,4,5, 7,4,6,
11,9,8, 10,9,11,
14,12,13, 15,12,14,
19,17,16, 18,17,19,
22,20,21, 23,20,22,
};
D3D11_BUFFER_DESC bd;
ZeroMemory( &bd, sizeof(bd) );
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( WORD ) * 36;
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA InitData;
ZeroMemory( &InitData, sizeof(InitData) );
InitData.pSysMem = indices;
hr = g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pCubeIndexBuffer );
if( FAILED( hr ) )
return hr;
}
// Create the constant buffers
{
D3D11_BUFFER_DESC bd;
ZeroMemory( &bd, sizeof(bd) );
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(CBChangesEveryFrame);
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.CPUAccessFlags = 0;
hr = g_pd3dDevice->CreateBuffer( &bd, NULL, &g_pCBChangesEveryFrame );
if( FAILED( hr ) )
return hr;
}
// camera
g_camera.setProjection( XMConvertToRadians(45.0f), width / (FLOAT)height, 0.1f, 100.0f );
g_camera.setView(XMVectorSet( 0.0f, -10.0f, -12.5f, 0.0f ), XMVectorSet( 0.0f, 0.0f, 0.0f, 0.0f ), XMVectorSet( 0.0f, 0.0f, -1.0f, 0.0f ));
return S_OK;
}
HRESULT DX11SceneRepHashSDF::OnD3D11CreateDevice( ID3D11Device* pd3dDevice )
{
HRESULT hr = S_OK;
char SDFBLOCKSIZE[5];
sprintf_s(SDFBLOCKSIZE, "%d", SDF_BLOCK_SIZE);
char HANDLECOLLISIONS[5];
sprintf_s(HANDLECOLLISIONS, "%d", GlobalAppState::getInstance().s_HANDLE_COLLISIONS);
char blockSize[5];
sprintf_s(blockSize, "%d", THREAD_GROUP_SIZE_SCENE_REP);
D3D_SHADER_MACRO macro[] = {{"groupthreads", blockSize}, { "SDF_BLOCK_SIZE", SDFBLOCKSIZE }, {"HANDLE_COLLISIONS", HANDLECOLLISIONS }, {0}};
D3D_SHADER_MACRO macro2[] = {{"groupthreads", blockSize}, { "SDF_BLOCK_SIZE", SDFBLOCKSIZE }, {0}};
D3D_SHADER_MACRO* validDefines = macro;
if(GlobalAppState::getInstance().s_HANDLE_COLLISIONS == 0)
{
validDefines = macro2;
}
ID3DBlob* pBlob = NULL;
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "integrateCS", "cs_5_0", &pBlob, validDefines));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_SDFVoxelHashIntegrate));
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "resetHeapCS", "cs_5_0", &pBlob, validDefines));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_SDFVoxelHashResetHeap));
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "resetHashCS", "cs_5_0", &pBlob, validDefines));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_SDFVoxelHashResetHash));
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "starveVoxelsCS", "cs_5_0", &pBlob, validDefines));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_SDFVoxelStarve));
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "allocCS", "cs_5_0", &pBlob, validDefines));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_SDFVoxelHashAlloc));
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "decisionArrayFillerCS", "cs_5_0", &pBlob, validDefines));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_HashDecisionArrayFiller));
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "compactifyHashCS", "cs_5_0", &pBlob, validDefines));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_HashCompactify));
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "garbadgeCollectIdentifyCS", "cs_5_0", &pBlob, validDefines));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_GarbageCollectIdentify));
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "garbadgeCollectIdentifyOldCS", "cs_5_0", &pBlob, validDefines));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_GarbageCollectIdentifyOld));
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "garbadgeCollectFreeCS", "cs_5_0", &pBlob, validDefines));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_GarbageCollectFree));
D3D_SHADER_MACRO macro_out = {"MOVE_OUT_FRUSTUM", "1"};
D3D_SHADER_MACRO macro_in = {"MOVE_IN_FRUSTUM", "1"};
D3D_SHADER_MACRO macro_and_out[10];
D3D_SHADER_MACRO macro_and_in[10];
AddDefinitionToMacro(validDefines, macro_and_out, macro_out);
AddDefinitionToMacro(validDefines, macro_and_in, macro_in);
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "removeAndIntegrateCS", "cs_5_0", &pBlob, macro_and_out));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_SDFVoxelHashRemoveAndIntegrateOutFrustum));
V_RETURN(CompileShaderFromFile(L"Shaders\\SceneRepSDF.hlsl", "removeAndIntegrateCS", "cs_5_0", &pBlob, macro_and_in));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_SDFVoxelHashRemoveAndIntegrateInFrustum));
SAFE_RELEASE(pBlob);
V_RETURN(s_PrefixSumScan.OnD3D11CreateDevice(pd3dDevice))
return hr;
}
void GPUParticleSystem::InitialiseSystem(ID3D11Device* device, ID3D11DeviceContext* deviceContext)
{
HRESULT hr;
//Compile the shaders
ID3DBlob* pVertexShaderBuffer = NULL;
hr = CompileShaderFromFile(L"VertexShader.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer);
ID3DBlob* pGeometryShaderBuffer = NULL;
hr = CompileShaderFromFile(L"VertexShader.hlsl", "GS", "gs_4_0", &pGeometryShaderBuffer);
ID3DBlob* pPixelShaderBuffer = NULL;
hr = CompileShaderFromFile(L"VertexShader.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer);
// Create the shaders
device->CreateVertexShader(pVertexShaderBuffer->GetBufferPointer(), pVertexShaderBuffer->GetBufferSize(), NULL, &vertexShader);
device->CreateGeometryShader(pGeometryShaderBuffer->GetBufferPointer(), pGeometryShaderBuffer->GetBufferSize(), NULL, &geometryShader);
device->CreatePixelShader(pPixelShaderBuffer->GetBufferPointer(), pPixelShaderBuffer->GetBufferSize(), NULL, &pixelShader);
pVertexShaderBuffer->Release();
pPixelShaderBuffer->Release();
//Create buffer constant buffer for draw calls
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(MatricesConstantBuffer);
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.CPUAccessFlags = 0;
device->CreateBuffer(&bd, NULL, &mConstBuffer);
//Create constant buffer for per frame variables
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(PerFrameVariables);
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.CPUAccessFlags = 0;
device->CreateBuffer(&bd, NULL, &perFrameVariablesBuffer);
//Create constant buffer for emitter variables
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DYNAMIC;
bd.ByteWidth = sizeof(EmitterParameters);
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
device->CreateBuffer(&bd, NULL, &emitterVariablesBuffer);
//Create constant buffer for variances
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DYNAMIC;
bd.ByteWidth = sizeof(EmitterParameters);
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
device->CreateBuffer(&bd, NULL, &variancesCB);
//Compile and create compute shaders
ID3DBlob *csInitBlob = nullptr;
ID3DBlob *csEmitBlob = nullptr;
ID3DBlob *csUpdateBlob = nullptr;
ID3DBlob *errorBlob;
hr = CompileComputeShader(L"InitialiseDeadList.hlsl", "main", device, &csInitBlob);
hr = CompileComputeShader(L"EmitParticles.hlsl", "main", device, &csEmitBlob);
//hr = CompileComputeShader(L"UpdateParticles.hlsl", "main", device, &csUpdateBlob);
//Assembles shader code for UpdateParticles
shaderFactory->ShaderAssembly();
//Compiles the code that has been put together in the shader factory
hr = D3DCompile(shaderFactory->updateShaderCode.c_str(), shaderFactory->updateShaderCode.length(), NULL, NULL, NULL,
"main", "cs_5_0", D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_SKIP_OPTIMIZATION | D3DCOMPILE_DEBUG, NULL, &csUpdateBlob, &errorBlob);
if (FAILED(hr))
{
std::string error = std::string((char*)errorBlob->GetBufferPointer());
errorBlob->Release();
return;
}
//Creates the compute shaders
hr = device->CreateComputeShader(csInitBlob->GetBufferPointer(), csInitBlob->GetBufferSize(), nullptr, &initialiseDeadListCS);
hr = device->CreateComputeShader(csEmitBlob->GetBufferPointer(), csEmitBlob->GetBufferSize(), nullptr, &emitParticlesCS);
hr = device->CreateComputeShader(csUpdateBlob->GetBufferPointer(), csUpdateBlob->GetBufferSize(), nullptr, &updateParticlesCS);
// The dead particle index list. Created as an append buffer
D3D11_BUFFER_DESC desc;
desc.ByteWidth = sizeof(UINT) * g_maxParticles;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS;
desc.CPUAccessFlags = 0;
desc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
desc.StructureByteStride = sizeof(UINT);
device->CreateBuffer(&desc, nullptr, &particleDeadListBuffer);
// Create constant buffers to copy the dead and alive list counters into
ZeroMemory(&desc, sizeof(desc));
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
desc.CPUAccessFlags = 0;
desc.ByteWidth = 4 * sizeof(UINT);
device->CreateBuffer(&desc, nullptr, &particleDeadListConstantBuffer);
D3D11_UNORDERED_ACCESS_VIEW_DESC uav;
ZeroMemory(&uav, sizeof(uav));
uav.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
uav.Buffer.Flags = D3D11_BUFFER_UAV_FLAG_APPEND;
uav.Buffer.FirstElement = 0;
uav.Format = DXGI_FORMAT_UNKNOWN;
uav.Buffer.NumElements = g_maxParticles;
device->CreateUnorderedAccessView(particleDeadListBuffer, &uav, &particleDeadListUAV);
//Initialise list of particles that are able to be emitted
InitialiseDeadList(deviceContext);
//Create the particle buffer/UAV/SRV
D3D11_BUFFER_DESC buffDesc;
ZeroMemory(&buffDesc, sizeof(buffDesc));
buffDesc.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
buffDesc.ByteWidth = sizeof(Particle)* g_maxParticles;
buffDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
buffDesc.StructureByteStride = sizeof(Particle);
buffDesc.Usage = D3D11_USAGE_DEFAULT;
Particle* particleList = new Particle[g_maxParticles];
//Initial particle values that are never used and are just for initialisation
for (int i = 0; i < g_maxParticles; ++i)
{
particleList[i].position = DirectX::XMFLOAT3(9999.0f, 0.0f, 9999.0f);
particleList[i].velocity = DirectX::XMFLOAT3(0.0f, 0.0f, 0.0f);
particleList[i].life = 0.0f;
particleList[i].age = 0.0f;
particleList[i].alive = false;
particleList[i].startSize = 0.0f;
particleList[i].endSize = 0.0f;
particleList[i].startColour = DirectX::XMFLOAT4(0.0f, 0.0f, 0.0f, 0.0f);
particleList[i].endColour = DirectX::XMFLOAT4(0.0f, 0.0f, 0.0f, 0.0f);
particleList[i].currentColour = DirectX::XMFLOAT4(0.0f, 0.0f, 0.0f, 0.0f);
particleList[i].currentSize = 0.0f;
}
D3D11_SUBRESOURCE_DATA data;
ZeroMemory(&data, sizeof(data));
data.pSysMem = particleList;
device->CreateBuffer(&buffDesc, &data, &particles);
delete[] particleList;
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
ZeroMemory(&srvDesc, sizeof(srvDesc));
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
srvDesc.Buffer.FirstElement = 0;
srvDesc.Format = DXGI_FORMAT_UNKNOWN;
srvDesc.Buffer.NumElements = g_maxParticles;
device->CreateShaderResourceView(particles, &srvDesc, &particlesSRV);
D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc;
ZeroMemory(&uavDesc, sizeof(uavDesc));
uavDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
uavDesc.Buffer.Flags = 0;
uavDesc.Buffer.FirstElement = 0;
uavDesc.Format = DXGI_FORMAT_UNKNOWN;
uavDesc.Buffer.NumElements = g_maxParticles;
device->CreateUnorderedAccessView(particles, &uavDesc, &particlesUAV);
//Buffer for the particle count
ZeroMemory(&desc, sizeof(desc));
desc.Usage = D3D11_USAGE_STAGING;
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
desc.ByteWidth = sizeof(UINT);
device->CreateBuffer(&desc, nullptr, &debugCounterBuffer);
//Loads in smoke particle texture to use with the particles using DirectXTK texture loader
hr = DirectX::CreateWICTextureFromFile(device, deviceContext, L"smoke.jpg", nullptr, &texture);
}
static __forceinline bool LOAD_VS(const std::string& DefineString, const char* name, VERTEXSHADER& vertex, ZZshProfile context)
{
bool flag = CompileShaderFromFile(vertex.program, DefineString, name, GL_VERTEX_SHADER);
vertex.set_context(context);
return flag;
}
/// 生成する
bool D3DShader::Create(DXGIManager *pDxgi)
{
if(m_pVsh)return true;
auto pDevice=pDxgi->GetD3DDevice();
// vertex shader
{
Microsoft::WRL::ComPtr<ID3DBlob> vblob;
HRESULT hr = CompileShaderFromFile(m_info.path, m_info.vs
, vblob.GetAddressOf());
if (FAILED(hr)) return false;
hr = pDevice->CreateVertexShader(
vblob->GetBufferPointer(), vblob->GetBufferSize()
, NULL, m_pVsh.ReleaseAndGetAddressOf());
if (FAILED(hr)) return false;
// vertex shader reflection
Microsoft::WRL::ComPtr<ID3D11ShaderReflection> pReflector;
hr = D3DReflect(vblob->GetBufferPointer(), vblob->GetBufferSize()
, IID_ID3D11ShaderReflection, &pReflector);
if (FAILED(hr)) return false;
D3D11_SHADER_DESC shaderdesc;
pReflector->GetDesc(&shaderdesc);
// Create InputLayout
std::vector<D3D11_INPUT_ELEMENT_DESC> vbElement;
for (size_t i = 0; i < shaderdesc.InputParameters; ++i){
D3D11_SIGNATURE_PARAMETER_DESC sigdesc;
pReflector->GetInputParameterDesc(i, &sigdesc);
auto format = GetDxgiFormat(sigdesc.ComponentType, sigdesc.Mask);
D3D11_INPUT_ELEMENT_DESC eledesc = {
sigdesc.SemanticName
, sigdesc.SemanticIndex
, format
, 0 // 決め打ち
, D3D11_APPEND_ALIGNED_ELEMENT // 決め打ち
, D3D11_INPUT_PER_VERTEX_DATA // 決め打ち
, 0 // 決め打ち
};
vbElement.push_back(eledesc);
}
if (!vbElement.empty()){
hr = pDevice->CreateInputLayout(&vbElement[0], vbElement.size(),
vblob->GetBufferPointer(), vblob->GetBufferSize(), &m_pInputLayout);
if (FAILED(hr)) return false;
}
}
// pixel shader
{
Microsoft::WRL::ComPtr<ID3DBlob> pblob;
auto hr = CompileShaderFromFile(m_info.path, m_info.ps
, pblob.GetAddressOf());
if (FAILED(hr)) return false;
hr = pDevice->CreatePixelShader(
pblob->GetBufferPointer(), pblob->GetBufferSize()
, NULL, m_pPsh.ReleaseAndGetAddressOf());
if (FAILED(hr)) return false;
}
return true;
}
HRESULT Application::InitShadersAndInputLayout()
{
HRESULT hr;
// Compile the vertex shader
ID3DBlob* pVSBlob = nullptr;
hr = CompileShaderFromFile(L"DX11 Framework.fx", "VS", "vs_4_0", &pVSBlob);
if (FAILED(hr))
{
MessageBox(nullptr,
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 = _pd3dDevice->CreateVertexShader(pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), nullptr, &_pVertexShader);
if (FAILED(hr))
{
pVSBlob->Release();
return hr;
}
// Compile the pixel shader
ID3DBlob* pPSBlob = nullptr;
hr = CompileShaderFromFile(L"DX11 Framework.fx", "PS", "ps_4_0", &pPSBlob);
if (FAILED(hr))
{
MessageBox(nullptr,
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 = _pd3dDevice->CreatePixelShader(pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), nullptr, &_pPixelShader);
pPSBlob->Release();
if (FAILED(hr))
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 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = ARRAYSIZE(layout);
// Create the input layout
hr = _pd3dDevice->CreateInputLayout(layout, numElements, pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(), &_pVertexLayout);
pVSBlob->Release();
if (FAILED(hr))
return hr;
// Set the input layout
_pImmediateContext->IASetInputLayout(_pVertexLayout);
D3D11_SAMPLER_DESC sampDesc;
ZeroMemory(&sampDesc, sizeof(sampDesc));
sampDesc.Filter = D3D11_FILTER_ANISOTROPIC;
sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
sampDesc.MinLOD = 0;
sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
hr = _pd3dDevice->CreateSamplerState(&sampDesc, &_pSamplerLinear);
return hr;
}
virtual HRESULT DeviceCreated(ID3D11Device* device)
{
HRESULT hr;
(void)hr;
{
D3D11_BUFFER_DESC buffer_desc;
ZeroMemory(&buffer_desc, sizeof(buffer_desc));
buffer_desc.Usage = D3D11_USAGE_DYNAMIC;
buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
buffer_desc.ByteWidth = sizeof(CBCamera);
_ASSERT((buffer_desc.ByteWidth % 16) == 0);
device->CreateBuffer(&buffer_desc, nullptr, &this->camera_cb);
}
{
D3D11_BUFFER_DESC buffer_desc;
ZeroMemory(&buffer_desc, sizeof(buffer_desc));
buffer_desc.Usage = D3D11_USAGE_DYNAMIC;
buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
buffer_desc.ByteWidth = sizeof(CBSceneObject);
_ASSERT((buffer_desc.ByteWidth % 16) == 0);
device->CreateBuffer(&buffer_desc, nullptr, &this->model_house_cb);
device->CreateBuffer(&buffer_desc, nullptr, &this->model_blades_cb);
}
{
D3DXVECTOR2 verts[6];
verts[0] = D3DXVECTOR2(-1.f, -1.f);
verts[1] = D3DXVECTOR2(-1.f, 1.f);
verts[2] = D3DXVECTOR2( 1.f, 1.f);
verts[3] = D3DXVECTOR2(-1.f, -1.f);
verts[4] = D3DXVECTOR2( 1.f, 1.f);
verts[5] = D3DXVECTOR2( 1.f, -1.f);
D3D11_BUFFER_DESC desc = { 6 * sizeof(D3DXVECTOR2), D3D11_USAGE_DEFAULT, D3D11_BIND_VERTEX_BUFFER, 0, 0 };
D3D11_SUBRESOURCE_DATA data = { (void *)verts, sizeof(D3DXVECTOR2), 6 * sizeof(D3DXVECTOR2) };
hr = device->CreateBuffer(&desc, &data, &this->quad_verts);
_ASSERT(!FAILED(hr));
}
Scene::load_model(device, "..\\..\\motionbluradvanced\\assets\\models\\house.obj", this->scene);
Scene::load_model(device, "..\\..\\motionbluradvanced\\assets\\models\\fan.obj", this->scene);
ID3DBlob* pShaderBuffer = NULL;
void* ShaderBufferData;
UINT ShaderBufferSize;
{
CompileShaderFromFile("..\\..\\motionbluradvanced\\assets\\shaders\\vs_scene.hlsl", "main", "vs_5_0", &pShaderBuffer);
ShaderBufferData = pShaderBuffer->GetBufferPointer();
ShaderBufferSize = pShaderBuffer->GetBufferSize();
device->CreateVertexShader(ShaderBufferData, ShaderBufferSize, nullptr, &this->scene_vs);
D3D11_INPUT_ELEMENT_DESC scene_layout_desc[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 1, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 2, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
device->CreateInputLayout(scene_layout_desc, sizeof(scene_layout_desc)/sizeof(D3D11_INPUT_ELEMENT_DESC), ShaderBufferData, ShaderBufferSize, &this->scene_layout);
CompileShaderFromFile("..\\..\\motionbluradvanced\\assets\\shaders\\ps_scene.hlsl", "main", "ps_5_0", &pShaderBuffer);
ShaderBufferData = pShaderBuffer->GetBufferPointer();
ShaderBufferSize = pShaderBuffer->GetBufferSize();
device->CreatePixelShader(ShaderBufferData, ShaderBufferSize, nullptr, &this->scene_ps);
}
{
CompileShaderFromFile("..\\..\\motionbluradvanced\\assets\\shaders\\vs_quad.hlsl", "main", "vs_5_0", &pShaderBuffer);
ShaderBufferData = pShaderBuffer->GetBufferPointer();
ShaderBufferSize = pShaderBuffer->GetBufferSize();
device->CreateVertexShader(ShaderBufferData, ShaderBufferSize, nullptr, &this->quad_vs);
D3D11_INPUT_ELEMENT_DESC quad_layout_desc[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
hr = device->CreateInputLayout(quad_layout_desc, sizeof(quad_layout_desc)/sizeof(D3D11_INPUT_ELEMENT_DESC), ShaderBufferData, ShaderBufferSize, &this->quad_layout);
CompileShaderFromFile("..\\..\\motionbluradvanced\\assets\\shaders\\ps_quad.hlsl", "main", "ps_5_0", &pShaderBuffer);
ShaderBufferData = pShaderBuffer->GetBufferPointer();
ShaderBufferSize = pShaderBuffer->GetBufferSize();
device->CreatePixelShader(ShaderBufferData, ShaderBufferSize, nullptr, &this->quad_ps);
CompileShaderFromFile("..\\..\\motionbluradvanced\\assets\\shaders\\ps_depth.hlsl", "main", "ps_5_0", &pShaderBuffer);
ShaderBufferData = pShaderBuffer->GetBufferPointer();
ShaderBufferSize = pShaderBuffer->GetBufferSize();
device->CreatePixelShader(ShaderBufferData, ShaderBufferSize, nullptr, &this->depth_ps);
CompileShaderFromFile("..\\..\\motionbluradvanced\\assets\\shaders\\ps_tilemax.hlsl", "main", "ps_5_0", &pShaderBuffer);
ShaderBufferData = pShaderBuffer->GetBufferPointer();
ShaderBufferSize = pShaderBuffer->GetBufferSize();
device->CreatePixelShader(ShaderBufferData, ShaderBufferSize, nullptr, &this->velocity_tile_max_ps);
CompileShaderFromFile("..\\..\\motionbluradvanced\\assets\\shaders\\ps_neighbormax.hlsl", "main", "ps_5_0", &pShaderBuffer);
ShaderBufferData = pShaderBuffer->GetBufferPointer();
ShaderBufferSize = pShaderBuffer->GetBufferSize();
device->CreatePixelShader(ShaderBufferData, ShaderBufferSize, nullptr, &this->velocity_neighbor_max_ps);
CompileShaderFromFile("..\\..\\motionbluradvanced\\assets\\shaders\\ps_gather.hlsl", "main", "ps_5_0", &pShaderBuffer);
ShaderBufferData = pShaderBuffer->GetBufferPointer();
ShaderBufferSize = pShaderBuffer->GetBufferSize();
device->CreatePixelShader(ShaderBufferData, ShaderBufferSize, nullptr, &this->gather_ps);
}
{
D3D11_RASTERIZER_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.CullMode = D3D11_CULL_NONE;
desc.FillMode = D3D11_FILL_SOLID;
desc.AntialiasedLineEnable = FALSE;
desc.DepthBias = 0;
desc.DepthBiasClamp = 0;
desc.DepthClipEnable = TRUE;
desc.FrontCounterClockwise = FALSE;
desc.MultisampleEnable = TRUE;
desc.ScissorEnable = FALSE;
desc.SlopeScaledDepthBias = 0;
device->CreateRasterizerState(&desc, &this->rs_state);
}
{
D3D11_SAMPLER_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
desc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
desc.MipLODBias = 0.0f;
desc.MaxAnisotropy = 1;
desc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
desc.BorderColor[0] = 0.f; desc.BorderColor[0] = 0.f; desc.BorderColor[0] = 0.f; desc.BorderColor[0] = 0.f;
desc.MinLOD = 0;
desc.MaxLOD = D3D11_FLOAT32_MAX;
device->CreateSamplerState(&desc, &this->samp_point_wrap);
}
{
D3D11_SAMPLER_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
desc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
desc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
desc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
desc.MipLODBias = 0.0f;
desc.MaxAnisotropy = 1;
desc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
desc.BorderColor[0] = 0.f; desc.BorderColor[0] = 0.f; desc.BorderColor[0] = 0.f; desc.BorderColor[0] = 0.f;
desc.MinLOD = 0;
desc.MaxLOD = D3D11_FLOAT32_MAX;
device->CreateSamplerState(&desc, &this->samp_point_clamp);
}
{
D3D11_SAMPLER_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
desc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
desc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
desc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
desc.MipLODBias = 0.0f;
desc.MaxAnisotropy = 1;
desc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
desc.BorderColor[0] = 0.f; desc.BorderColor[0] = 0.f; desc.BorderColor[0] = 0.f; desc.BorderColor[0] = 0.f;
desc.MinLOD = 0;
desc.MaxLOD = D3D11_FLOAT32_MAX;
device->CreateSamplerState(&desc, &this->samp_linear_clamp);
}
{
D3D11_DEPTH_STENCIL_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.StencilEnable = FALSE;
desc.DepthEnable = TRUE;
desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
desc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
device->CreateDepthStencilState(&desc, &this->ds_state);
}
{
D3D11_DEPTH_STENCIL_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.StencilEnable = FALSE;
desc.DepthEnable = FALSE;
desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
desc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
device->CreateDepthStencilState(&desc, &this->ds_state_disabled);
}
{
D3D11_BLEND_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.AlphaToCoverageEnable = FALSE;
desc.IndependentBlendEnable = TRUE;
desc.RenderTarget[0].BlendEnable = TRUE;
desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
device->CreateBlendState(&desc, &this->blend_state);
}
{
D3D11_BLEND_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.RenderTarget[0].BlendEnable = FALSE;
desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
device->CreateBlendState(&desc, &this->blend_state_disabled);
}
{
// Load the background texture
Scene::load_texture(device, L"..\\..\\motionbluradvanced\\assets\\models\\sky_cube.dds", &this->background_srv);
}
return S_OK;
}
bool TextureShader::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
D3D11_SAMPLER_DESC samplerDesc;
// Initialize the pointers this function will use to null.
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
result = CompileShaderFromFile(L"Tutorial04.fx", "VS", "vs_4_0", &vertexShaderBuffer);
if (FAILED(result)) {
return false;
}
result = CompileShaderFromFile(L"Tutorial04.fx", "PS", "vs_4_0", &vertexShaderBuffer);
if (FAILED(result)) {
return false;
}
// Compile the vertex shader code.
//result = D3DCompileFromFile(vsFilename, NULL, NULL, "TextureVertexShader", "vs_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0,
// &vertexShaderBuffer, &errorMessage);
//if (FAILED(result))
//{
// // If the shader failed to compile it should have writen something to the error message.
// if (errorMessage)
// {
// OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
// }
// // If there was nothing in the error message then it simply could not find the shader file itself.
// else
// {
// MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
// }
// return false;
//}
//// Compile the pixel shader code.
//result = D3DCompileFromFile(psFilename, NULL, NULL, "TexturePixelShader", "ps_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0,
// &pixelShaderBuffer, &errorMessage);
//if (FAILED(result))
//{
// // If the shader failed to compile it should have writen something to the error message.
// if (errorMessage)
// {
// OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
// }
// // If there was nothing in the error message then it simply could not find the file itself.
// else
// {
// MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
// }
// return false;
//}
// Create the vertex shader from the buffer.
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
return false;
}
// Create the pixel shader from the buffer.
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
return false;
}
// Create the vertex input layout description.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
// Get a count of the elements in the layout.
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// Create the vertex input layout.
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
return false;
}
// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
return false;
}
// Create a texture sampler state description.
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
// Create the texture sampler state.
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
return false;
}
return true;
}
//--------------------------------------------------------------------------------------
// render callback
//--------------------------------------------------------------------------------------
void CALLBACK OnD3D11FrameRender( ID3D11Device* pd3dDevice,
ID3D11DeviceContext* pd3dImmediateContext,
double fTime,
float fElapsedTime, void* pUserContext )
{
static int s_iCounter = 0;
// If the settings dialog is being shown, then render it instead of rendering the app's scene
if( g_D3DSettingsDlg.IsActive() )
{
g_D3DSettingsDlg.OnRender( fElapsedTime );
return;
}
if( g_pScenePS == NULL && s_iCounter == 0 )
{
s_iCounter = 4;
}
if( s_iCounter > 0 )
s_iCounter --;
if( s_iCounter == 1 && g_pScenePS == NULL )
{
HRESULT hr = S_OK;
// Create the shaders
ID3DBlob* pBlob = NULL;
// VS
hr = CompileShaderFromFile( L"ContactHardeningShadows11.hlsl", "VS_RenderScene", "vs_5_0", &pBlob );
hr = pd3dDevice->CreateVertexShader( pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &g_pSceneVS );
DXUT_SetDebugName( g_pSceneVS, "VS_RenderScene" );
// Define our scene vertex data layout
const D3D11_INPUT_ELEMENT_DESC SceneLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXTURE", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
hr = pd3dDevice->CreateInputLayout( SceneLayout, ARRAYSIZE( SceneLayout ), pBlob->GetBufferPointer(),
pBlob->GetBufferSize(), &g_pSceneVertexLayout );
SAFE_RELEASE( pBlob );
DXUT_SetDebugName( g_pSceneVertexLayout, "SceneLayout" );
hr = CompileShaderFromFile( L"ContactHardeningShadows11.hlsl", "VS_RenderSceneSM", "vs_5_0", &pBlob );
hr = pd3dDevice->CreateVertexShader( pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &g_pSM_VS );
SAFE_RELEASE( pBlob );
DXUT_SetDebugName( g_pSM_VS, "VS_RenderSceneSM" );
// PS
hr = CompileShaderFromFile( L"ContactHardeningShadows11.hlsl", "PS_RenderScene", "ps_5_0", &pBlob );
hr = pd3dDevice->CreatePixelShader( pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &g_pScenePS );
SAFE_RELEASE( pBlob );
DXUT_SetDebugName( g_pScenePS, "PS_RenderScene" );
s_iCounter = 0;
}
else if( g_pScenePS != NULL )
{
ID3D11RenderTargetView* pRTV[2] = { NULL,NULL };
ID3D11ShaderResourceView* pSRV[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
// Array of our samplers
ID3D11SamplerState* ppSamplerStates[3] = { g_pSamplePoint, g_pSampleLinear, g_pSamplePointCmp };
pd3dImmediateContext->PSSetSamplers( 0, 3, ppSamplerStates );
// Store off original render target, this is the back buffer of the swap chain
ID3D11RenderTargetView* pOrigRTV = DXUTGetD3D11RenderTargetView();
ID3D11DepthStencilView* pOrigDSV = DXUTGetD3D11DepthStencilView();
// Clear the render target
float ClearColor[4] = { 0.0f, 0.25f, 0.25f, 0.55f };
pd3dImmediateContext->ClearRenderTargetView( DXUTGetD3D11RenderTargetView(),
ClearColor );
pd3dImmediateContext->ClearDepthStencilView( DXUTGetD3D11DepthStencilView(),
D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL,
1.0, 0 );
// Get the projection & view matrix from the camera class
D3DXMATRIXA16 mWorld;
D3DXMATRIXA16 mView;
D3DXMATRIXA16 mProj;
D3DXMATRIXA16 mViewProjLight;
D3DXMATRIXA16 mWorldViewProjection;
D3DXVECTOR3 vLightDir;
// disable color writes
pd3dImmediateContext->OMSetBlendState(g_pBlendStateColorWritesOff, 0, 0xffffffff);
RenderShadowMap( pd3dDevice, pd3dImmediateContext, mViewProjLight, vLightDir );
// enable color writes
pd3dImmediateContext->OMSetBlendState(g_pBlendStateNoBlend, 0, 0xffffffff);
mView = *g_Camera.GetViewMatrix();
mProj = *g_Camera.GetProjMatrix();
mWorldViewProjection = mView * mProj;
// Setup the constant buffer for the scene vertex shader
D3D11_MAPPED_SUBRESOURCE MappedResource;
pd3dImmediateContext->Map( g_pcbConstants, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource );
CB_CONSTANTS* pConstants = ( CB_CONSTANTS* )MappedResource.pData;
D3DXMatrixTranspose( &pConstants->f4x4WorldViewProjection, &mWorldViewProjection );
D3DXMatrixTranspose( &pConstants->f4x4WorldViewProjLight, &mViewProjLight );
pConstants->vShadowMapDimensions = D3DXVECTOR4(g_fShadowMapWidth, g_fShadowMapHeight,
1.0f/g_fShadowMapWidth,
1.0f/g_fShadowMapHeight);
pConstants->vLightDir = D3DXVECTOR4( vLightDir.x, vLightDir.y,
vLightDir.z, 0.0f );
pConstants->fSunWidth = g_fSunWidth;
pd3dImmediateContext->Unmap( g_pcbConstants, 0 );
pd3dImmediateContext->VSSetConstantBuffers( g_iCONSTANTSCBBind, 1, &g_pcbConstants );
pd3dImmediateContext->PSSetConstantBuffers( g_iCONSTANTSCBBind, 1, &g_pcbConstants );
// Set the shaders
pd3dImmediateContext->VSSetShader( g_pSceneVS, NULL, 0 );
pd3dImmediateContext->PSSetShader( g_pScenePS, NULL, 0 );
// Set the vertex buffer format
pd3dImmediateContext->IASetInputLayout( g_pSceneVertexLayout );
// Rebind to original back buffer and depth buffer
pRTV[0] = pOrigRTV;
pd3dImmediateContext->OMSetRenderTargets(1, pRTV, pOrigDSV );
// set the shadow map
pd3dImmediateContext->PSSetShaderResources( 1, 1, &g_pDepthTextureSRV );
// Render the scene
g_SceneMesh.Render( pd3dImmediateContext, 0 );
g_Poles.Render( pd3dImmediateContext, 0 );
// restore resources
pd3dImmediateContext->PSSetShaderResources( 0, 8, pSRV );
}
// Render GUI
DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"HUD / Stats" );
if( g_bGuiVisible )
{
g_HUD.OnRender( fElapsedTime );
g_SampleUI.OnRender( fElapsedTime );
}
RenderText();
DXUT_EndPerfEvent();
}
/** Loads shader */
XRESULT D3D11VShader::LoadShader(const char* vertexShader, int layout, std::vector<D3D10_SHADER_MACRO>& makros)
{
HRESULT hr;
D3D11GraphicsEngine* engine = (D3D11GraphicsEngine *)Engine::GraphicsEngine;
ID3DBlob* vsBlob;
LogInfo() << "Compilling vertex shader: " << vertexShader;
File = vertexShader;
// Compile shader
if(FAILED(CompileShaderFromFile(vertexShader, "VSMain", "vs_4_0", &vsBlob, makros)))
{
return XR_FAILED;
}
// Create the shader
LE(engine->GetDevice()->CreateVertexShader(vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(), NULL, &VertexShader));
#ifndef PUBLIC_RELEASE
VertexShader->SetPrivateData(WKPDID_D3DDebugObjectName, strlen(vertexShader), vertexShader);
#endif
const D3D11_INPUT_ELEMENT_DESC layout1[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "DIFFUSE", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
const D3D11_INPUT_ELEMENT_DESC layout2[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
const D3D11_INPUT_ELEMENT_DESC layout3[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "POSITION", 1, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "POSITION", 2, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "POSITION", 3, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "DIFFUSE", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "BONEIDS", 0, DXGI_FORMAT_R8G8B8A8_UINT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "WEIGHTS", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
const D3D11_INPUT_ELEMENT_DESC layout4[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "DIFFUSE", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "INSTANCE_WORLD_MATRIX", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
{ "INSTANCE_WORLD_MATRIX", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
{ "INSTANCE_WORLD_MATRIX", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
{ "INSTANCE_WORLD_MATRIX", 3, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
{ "INSTANCE_COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1 },
{ "INSTANCE_SCALE", 0, DXGI_FORMAT_R32G32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1 },
};
const D3D11_INPUT_ELEMENT_DESC layout5[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
const D3D11_INPUT_ELEMENT_DESC layout6[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "DIFFUSE", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
const D3D11_INPUT_ELEMENT_DESC layout7[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "DIFFUSE", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
const D3D11_INPUT_ELEMENT_DESC layout8[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
const D3D11_INPUT_ELEMENT_DESC layout9[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "INSTANCE_WORLD_MATRIX", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
{ "INSTANCE_WORLD_MATRIX", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
{ "INSTANCE_WORLD_MATRIX", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
{ "INSTANCE_WORLD_MATRIX", 3, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
};
const D3D11_INPUT_ELEMENT_DESC layout10[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "DIFFUSE", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "INSTANCE_WORLD_MATRIX", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
{ "INSTANCE_WORLD_MATRIX", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
{ "INSTANCE_WORLD_MATRIX", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
{ "INSTANCE_WORLD_MATRIX", 3, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1},
//{ "INSTANCE_COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1 },
};
switch (layout)
{
case 1:
LE(engine->GetDevice()->CreateInputLayout(layout1, ARRAYSIZE(layout1), vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(), &InputLayout));
break;
case 2:
LE(engine->GetDevice()->CreateInputLayout(layout2, ARRAYSIZE(layout2), vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(), &InputLayout));
break;
case 3:
LE(engine->GetDevice()->CreateInputLayout(layout3, ARRAYSIZE(layout3), vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(), &InputLayout));
break;
case 4:
LE(engine->GetDevice()->CreateInputLayout(layout4, ARRAYSIZE(layout4), vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(), &InputLayout));
break;
case 5:
LE(engine->GetDevice()->CreateInputLayout(layout5, ARRAYSIZE(layout5), vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(), &InputLayout));
break;
case 6:
LE(engine->GetDevice()->CreateInputLayout(layout6, ARRAYSIZE(layout6), vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(), &InputLayout));
break;
case 7:
LE(engine->GetDevice()->CreateInputLayout(layout7, ARRAYSIZE(layout7), vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(), &InputLayout));
break;
case 8:
LE(engine->GetDevice()->CreateInputLayout(layout8, ARRAYSIZE(layout8), vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(), &InputLayout));
break;
case 9:
LE(engine->GetDevice()->CreateInputLayout(layout9, ARRAYSIZE(layout9), vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(), &InputLayout));
break;
case 10:
LE(engine->GetDevice()->CreateInputLayout(layout10, ARRAYSIZE(layout10), vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(), &InputLayout));
break;
}
return XR_SUCCESS;
}
bool GGbsModel::Init(TCHAR* strFileName, TCHAR* strShaderName) {
HRESULT hr = S_OK;
//파싱, 필요한 처리 시작.
CStopwatch stopwatch;
//I_AseParser
I_GbsParser.InitGbsModel(strFileName, this);
//필요한 처리 끝.
stopwatch.Output(L"Init()");
// Create the sample state
D3D11_SAMPLER_DESC sampDesc;
ZeroMemory(&sampDesc, sizeof(sampDesc));
sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
sampDesc.MinLOD = 0;
sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
hr = g_pd3dDevice->CreateSamplerState(&sampDesc, m_pSamplerLinear.GetAddressOf());
if (FAILED(hr))
return hr;
// Compile the vertex shader
ID3DBlob* pVSBlob = NULL;
hr = CompileShaderFromFile(strShaderName, "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, m_pVertexShader.GetAddressOf());
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 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 40, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = ARRAYSIZE(layout);
// Create the input layout
hr = g_pd3dDevice->CreateInputLayout(layout, numElements, pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(), m_pVertexLayout.GetAddressOf());
pVSBlob->Release();
if (FAILED(hr))
return hr;
// Set the input layout
g_pImmediateContext->IASetInputLayout(m_pVertexLayout.Get());
// Compile the pixel shader
ID3DBlob* pPSBlob = NULL;
hr = CompileShaderFromFile(strShaderName, "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, m_pPixelShader.GetAddressOf());
pPSBlob->Release();
if (FAILED(hr))
return hr;
if (m_vGeomObj.size() == 1)
SingleModelInit();
else
MultiModelInit();
return true;
};
HRESULT DX11NormalizeReduction::OnD3D11CreateDevice( ID3D11Device* pd3dDevice )
{
HRESULT hr = S_OK;
m_pComputeShaderNorm = new ID3D11ComputeShader*[GlobalCameraTrackingState::getInstance().s_maxLevels];
m_pComputeShader2Norm = new ID3D11ComputeShader*[GlobalCameraTrackingState::getInstance().s_maxLevels];
m_pAuxBufNorm = new ID3D11Buffer*[GlobalCameraTrackingState::getInstance().s_maxLevels];
m_pAuxBufNormCPU = new ID3D11Buffer*[GlobalCameraTrackingState::getInstance().s_maxLevels];
m_pAuxBufNormSRV = new ID3D11ShaderResourceView*[GlobalCameraTrackingState::getInstance().s_maxLevels];
m_pAuxBufNormUAV = new ID3D11UnorderedAccessView*[GlobalCameraTrackingState::getInstance().s_maxLevels];
/////////////////////////////////////////////////////
// Normalize Reduction
/////////////////////////////////////////////////////
D3D11_BUFFER_DESC Desc;
Desc.Usage = D3D11_USAGE_DYNAMIC;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
Desc.MiscFlags = 0;
Desc.ByteWidth = sizeof(CBufferNorm);
V_RETURN(pd3dDevice->CreateBuffer(&Desc, NULL, &m_constantBufferNorm));
for(int level = GlobalCameraTrackingState::getInstance().s_maxLevels-1; level >= 0; level--)
{
char BUCKET_SIZE_NORM[5];
char NUM_BUCKETS_NORM[5];
sprintf_s(BUCKET_SIZE_NORM, "%d", GlobalCameraTrackingState::getInstance().s_blockSizeNormalize[level]);
sprintf_s(NUM_BUCKETS_NORM, "%d", GlobalCameraTrackingState::getInstance().s_numBucketsNormalize[level]);
D3D_SHADER_MACRO shaderDefinesScanInBucketNorm[] = { { "groupthreads", BUCKET_SIZE_NORM }, { 0 } };
D3D_SHADER_MACRO shaderDefinesScanBucketResultNorm[] = { { "groupthreads", NUM_BUCKETS_NORM }, {"BUCKET_SIZE", BUCKET_SIZE_NORM}, { 0 } };
ID3DBlob* pBlobCS = NULL;
V_RETURN(CompileShaderFromFile( L"Shaders\\NormalizeReduction.hlsl", "CSScanInBucket", "cs_5_0", &pBlobCS, shaderDefinesScanInBucketNorm));
V_RETURN(pd3dDevice->CreateComputeShader(pBlobCS->GetBufferPointer(), pBlobCS->GetBufferSize(), NULL, &m_pComputeShaderNorm[level]));
SAFE_RELEASE(pBlobCS);
V_RETURN(CompileShaderFromFile(L"Shaders\\NormalizeReduction.hlsl", "CSScanBucketResult", "cs_5_0", &pBlobCS, shaderDefinesScanBucketResultNorm));
V_RETURN(pd3dDevice->CreateComputeShader(pBlobCS->GetBufferPointer(), pBlobCS->GetBufferSize(), NULL, &m_pComputeShader2Norm[level]));
SAFE_RELEASE(pBlobCS);
D3D11_BUFFER_DESC Desc;
ZeroMemory(&Desc, sizeof(Desc));
Desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS;
Desc.StructureByteStride = 8*sizeof(float);
Desc.ByteWidth = Desc.StructureByteStride*GlobalCameraTrackingState::getInstance().s_numBucketsNormalize[level];
Desc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
Desc.Usage = D3D11_USAGE_DEFAULT;
V_RETURN(pd3dDevice->CreateBuffer(&Desc, NULL, &m_pAuxBufNorm[level]));
D3D11_SHADER_RESOURCE_VIEW_DESC DescRV;
ZeroMemory( &DescRV, sizeof( DescRV ) );
DescRV.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
DescRV.Format = DXGI_FORMAT_UNKNOWN;
DescRV.Buffer.FirstElement = 0;
DescRV.Buffer.NumElements = GlobalCameraTrackingState::getInstance().s_numBucketsNormalize[level];
V_RETURN(pd3dDevice->CreateShaderResourceView(m_pAuxBufNorm[level], &DescRV, &m_pAuxBufNormSRV[level]));
D3D11_UNORDERED_ACCESS_VIEW_DESC DescUAV;
ZeroMemory( &DescUAV, sizeof(DescUAV) );
DescUAV.Format = DXGI_FORMAT_UNKNOWN;
DescUAV.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
DescUAV.Buffer.FirstElement = 0;
DescUAV.Buffer.NumElements = GlobalCameraTrackingState::getInstance().s_numBucketsNormalize[level];
V_RETURN( pd3dDevice->CreateUnorderedAccessView(m_pAuxBufNorm[level], &DescUAV, &m_pAuxBufNormUAV[level]));
// Create Output Buffer CPU
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
Desc.BindFlags = 0;
Desc.Usage = D3D11_USAGE_STAGING;
V_RETURN(pd3dDevice->CreateBuffer(&Desc, NULL, &m_pAuxBufNormCPU[level]));
}
return hr;
}
HRESULT DXSourceWindow::CreateShaderResources()
{
HRESULT hr = S_OK;
// Set up constant buffer
D3D11_BUFFER_DESC Desc;
Desc.Usage = D3D11_USAGE_DYNAMIC;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
Desc.MiscFlags = 0;
Desc.ByteWidth = sizeof( CUBE_CB );
hr = m_pd3dDevice->CreateBuffer( &Desc, NULL, &m_Cube_pcb );
PASS_TEST( hr );
// create vertex buffer
const float pVertices[] = { -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f,
0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f,
-0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f,
-0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, 0.5f,
-0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f,
-0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f };
const float pNormal[] = { 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f,
-1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f };
const float pTexture[] = { 1.0f,0.0f, 1.0f,1.0f, 0.0f,1.0f, 0.0f,0.0f,
1.0f,0.0f, 1.0f,1.0f, 0.0f,1.0f, 0.0f,0.0f,
1.0f,0.0f, 1.0f,1.0f, 0.0f,1.0f, 0.0f,0.0f,
1.0f,0.0f, 1.0f,1.0f, 0.0f,1.0f, 0.0f,0.0f,
1.0f,0.0f, 1.0f,1.0f, 0.0f,1.0f, 0.0f,0.0f,
1.0f,0.0f, 1.0f,1.0f, 0.0f,1.0f, 0.0f,0.0f};
const float pColors[] = { 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f };
CUBE_Vertex1 verts[24];
for (int i=0; i<24; i++)
{
verts[i].pos = D3DXVECTOR3(pVertices[3*i], pVertices[3*i+1], pVertices[3*i+2]);
verts[i].texture = D3DXVECTOR2(pTexture[2*i], pTexture[2*i+1] );
verts[i].normal = D3DXVECTOR3(pNormal[3*i], pNormal[3*i+1], pNormal[3*i+2] );
verts[i].color = D3DXVECTOR3(pColors[3*i], pColors[3*i+1], pColors[3*i+2]);
}
D3D11_BUFFER_DESC vbDesc = {0};
vbDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; // Type of resource
vbDesc.ByteWidth = 24*sizeof(CUBE_Vertex1); // size in bytes
vbDesc.Usage = D3D11_USAGE_DEFAULT;
vbDesc.CPUAccessFlags = 0;
vbDesc.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA vbData = {0};
vbData.pSysMem = verts;
hr = m_pd3dDevice->CreateBuffer( &vbDesc, &vbData, &m_Cube_pVertexBuffer);
PASS_TEST(hr);
// create index buffer
int indices[36] = {-1};
for (int i=0; i<6; i++)
{
indices[6*i]=4*i; indices[6*i+1]=4*i+1; indices[6*i+2]=4*i+3;
indices[6*i+3]=4*i+1; indices[6*i+4]=4*i+2; indices[6*i+5]=4*i+3;
}
vbDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
vbDesc.ByteWidth = 36*sizeof(unsigned int);
vbData.pSysMem = indices;
hr = m_pd3dDevice->CreateBuffer( &vbDesc, &vbData, &m_Cube_pIndexBuffer );
PASS_TEST(hr);
// Compile the shaders using the lowest possible profile for broadest feature level support
ID3DBlob* pVertexShaderBuffer = NULL;
hr = CompileShaderFromFile(L"DrawCube.hlsl", "VSMain", "vs_4_0_level_9_1", &pVertexShaderBuffer );
if ( hr == D3D11_ERROR_FILE_NOT_FOUND )
{
MessageBoxA(NULL,"ERROR, file DrawCube.hlsl not found.","DirectGMA",NULL);
return D3D11_ERROR_FILE_NOT_FOUND;
}
PASS_TEST(hr);
hr = m_pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(), pVertexShaderBuffer->GetBufferSize(), NULL, &m_Cube_pVertexShader );
PASS_TEST(hr);
ID3DBlob* pPixelShaderBuffer = NULL;
hr = CompileShaderFromFile( L"DrawCube.hlsl", "PSMain", "ps_4_0_level_9_1", &pPixelShaderBuffer );
PASS_TEST(hr);
hr = m_pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(), pPixelShaderBuffer->GetBufferSize(), NULL, &m_Cube_pPixelShader );
PASS_TEST(hr);
// Create our vertex input layout
const D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXTURE", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 20, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 32, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
hr = m_pd3dDevice->CreateInputLayout( layout, ARRAYSIZE( layout ), pVertexShaderBuffer->GetBufferPointer(), pVertexShaderBuffer->GetBufferSize(), &m_Cube_pVertexLayout11 );
PASS_TEST(hr);
SAFE_RELEASE( pVertexShaderBuffer );
SAFE_RELEASE( pPixelShaderBuffer );
// Create a sampler state
D3D11_SAMPLER_DESC sampDesc;
ZeroMemory( &sampDesc, sizeof(sampDesc) );
sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
sampDesc.MinLOD = 0;
sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
hr = m_pd3dDevice->CreateSamplerState( &sampDesc, &m_Cube_pSamplerLinear );
PASS_TEST(hr);
// Set the raster state
D3D11_RASTERIZER_DESC RasterizerDesc;
RasterizerDesc.FillMode = D3D11_FILL_SOLID;
RasterizerDesc.CullMode = D3D11_CULL_NONE;
RasterizerDesc.FrontCounterClockwise = TRUE;
RasterizerDesc.DepthBias = 0;
RasterizerDesc.DepthBiasClamp = 0.0f;
RasterizerDesc.SlopeScaledDepthBias = 0.0f;
RasterizerDesc.DepthClipEnable = TRUE;
RasterizerDesc.ScissorEnable = FALSE;
RasterizerDesc.MultisampleEnable = FALSE;
RasterizerDesc.AntialiasedLineEnable = FALSE;
hr = m_pd3dDevice->CreateRasterizerState( &RasterizerDesc, &m_Cube_pRasterizerStateSolid );
PASS_TEST(hr);
// Set state Objects
m_pImmediateContext->RSSetState( m_Cube_pRasterizerStateSolid );
hr = D3DX11CreateShaderResourceViewFromFile( m_pd3dDevice, L"amdlogo.dds", NULL, NULL, &m_Cube_pTextureRV, NULL );
if ( hr == D3D11_ERROR_FILE_NOT_FOUND )
{
MessageBoxA(NULL,"ERROR, file amdlogo.dds not found.","DirectGMA",NULL);
return D3D11_ERROR_FILE_NOT_FOUND;
}
PASS_TEST(hr);
return S_OK;
}
// Load the assets.
HRESULT VolumetricAnimation::LoadAssets()
{
HRESULT hr;
// Create a root signature consisting of a descriptor table with a CBV SRV and a sampler.
{
CD3DX12_DESCRIPTOR_RANGE ranges[3];
CD3DX12_ROOT_PARAMETER rootParameters[3];
ranges[0].Init( D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0 );
ranges[1].Init( D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1, 0 );
ranges[2].Init( D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 1, 0 );
rootParameters[RootParameterCBV].InitAsDescriptorTable( 1, &ranges[0], D3D12_SHADER_VISIBILITY_ALL );
rootParameters[RootParameterSRV].InitAsDescriptorTable( 1, &ranges[1], D3D12_SHADER_VISIBILITY_PIXEL );
rootParameters[RootParameterUAV].InitAsDescriptorTable( 1, &ranges[2], D3D12_SHADER_VISIBILITY_ALL );
D3D12_STATIC_SAMPLER_DESC sampler = {};
sampler.Filter = D3D12_FILTER_MIN_MAG_MIP_POINT;
sampler.AddressU = D3D12_TEXTURE_ADDRESS_MODE_BORDER;
sampler.AddressV = D3D12_TEXTURE_ADDRESS_MODE_BORDER;
sampler.AddressW = D3D12_TEXTURE_ADDRESS_MODE_BORDER;
sampler.MipLODBias = 0;
sampler.MaxAnisotropy = 0;
sampler.ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER;
sampler.BorderColor = D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK;
sampler.MinLOD = 0.0f;
sampler.MaxLOD = D3D12_FLOAT32_MAX;
sampler.ShaderRegister = 0;
sampler.RegisterSpace = 0;
sampler.ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;
// Allow input layout and deny unnecessary access to certain pipeline stages.
D3D12_ROOT_SIGNATURE_FLAGS rootSignatureFlags =
D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT |
D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS;
CD3DX12_ROOT_SIGNATURE_DESC rootSignatureDesc;
rootSignatureDesc.Init( _countof(rootParameters), rootParameters, 1, &sampler, rootSignatureFlags );
ComPtr<ID3DBlob> signature;
ComPtr<ID3DBlob> error;
V( D3D12SerializeRootSignature( &rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error ) );
if ( error ) PRINTERROR( reinterpret_cast< const char* >( error->GetBufferPointer() ) );
VRET( m_device->CreateRootSignature( 0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS( &m_graphicsRootSignature ) ) );
DXDebugName( m_graphicsRootSignature );
// Create compute signature. Must change visibility for the SRV.
rootParameters[RootParameterSRV].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
CD3DX12_ROOT_SIGNATURE_DESC computeRootSignatureDesc( _countof( rootParameters ), rootParameters, 0, nullptr );
VRET( D3D12SerializeRootSignature( &computeRootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error ) );
VRET( m_device->CreateRootSignature( 0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS( &m_computeRootSignature ) ) );
}
// Create the pipeline state, which includes compiling and loading shaders.
{
ComPtr<ID3DBlob> vertexShader;
ComPtr<ID3DBlob> pixelShader;
ComPtr<ID3DBlob> computeShader;
UINT compileFlags = 0;
VRET( CompileShaderFromFile( GetAssetFullPath( _T( "VolumetricAnimation_shader.hlsl" ) ).c_str(), nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE, "vsmain", "vs_5_0", compileFlags, 0, &vertexShader ) );
VRET( CompileShaderFromFile( GetAssetFullPath( _T( "VolumetricAnimation_shader.hlsl" ) ).c_str(), nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE, "psmain", "ps_5_0", compileFlags, 0, &pixelShader ) );
VRET( CompileShaderFromFile( GetAssetFullPath( _T( "VolumetricAnimation_shader.hlsl" ) ).c_str(), nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE, "csmain", "cs_5_0", compileFlags, 0, &computeShader ) );
// Define the vertex input layout.
D3D12_INPUT_ELEMENT_DESC inputElementDescs[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
};
CD3DX12_DEPTH_STENCIL_DESC depthStencilDesc( D3D12_DEFAULT );
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL;
depthStencilDesc.StencilEnable = FALSE;
// Describe and create the graphics pipeline state object (PSO).
D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
psoDesc.InputLayout = { inputElementDescs, _countof( inputElementDescs ) };
psoDesc.pRootSignature = m_graphicsRootSignature.Get();
psoDesc.VS = { reinterpret_cast< UINT8* >( vertexShader->GetBufferPointer() ), vertexShader->GetBufferSize() };
psoDesc.PS = { reinterpret_cast< UINT8* >( pixelShader->GetBufferPointer() ), pixelShader->GetBufferSize() };
psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC( D3D12_DEFAULT );
psoDesc.BlendState = CD3DX12_BLEND_DESC( D3D12_DEFAULT );
psoDesc.DepthStencilState = depthStencilDesc;
psoDesc.SampleMask = UINT_MAX;
psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
psoDesc.NumRenderTargets = 1;
psoDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
psoDesc.DSVFormat = DXGI_FORMAT_D32_FLOAT;
psoDesc.SampleDesc.Count = 1;
VRET( m_device->CreateGraphicsPipelineState( &psoDesc, IID_PPV_ARGS( &m_pipelineState ) ) );
DXDebugName( m_pipelineState );
// Describe and create the compute pipeline state object (PSO).
D3D12_COMPUTE_PIPELINE_STATE_DESC computePsoDesc = {};
computePsoDesc.pRootSignature = m_computeRootSignature.Get();
computePsoDesc.CS = { reinterpret_cast< UINT8* >( computeShader->GetBufferPointer() ), computeShader->GetBufferSize() };
VRET( m_device->CreateComputePipelineState( &computePsoDesc, IID_PPV_ARGS( &m_computeState ) ) );
DXDebugName( m_computeState );
}
// Create the compute command list.
VRET( m_device->CreateCommandList( 0, D3D12_COMMAND_LIST_TYPE_COMPUTE, m_computeCmdAllocator.Get(),m_computeState.Get(), IID_PPV_ARGS( &m_computeCmdList ) ) );
DXDebugName( m_computeCmdList );
VRET( m_computeCmdList->Close() );
// Create the graphics command list.
VRET( m_device->CreateCommandList( 0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_graphicCmdAllocator.Get(), m_pipelineState.Get(), IID_PPV_ARGS( &m_graphicCmdList ) ) );
DXDebugName( m_graphicCmdList );
// Note: ComPtr's are CPU objects but this resource needs to stay in scope until
// the command list that references it has finished executing on the GPU.
// We will flush the GPU at the end of this method to ensure the resource is not
// prematurely destroyed.
ComPtr<ID3D12Resource> volumeBufferUploadHeap;
// Create the volumeBuffer.
{
UINT volumeBufferSize = m_volumeDepth*m_volumeHeight*m_volumeWidth * 4 * sizeof( UINT8 );
D3D12_RESOURCE_DESC bufferDesc = CD3DX12_RESOURCE_DESC::Buffer( volumeBufferSize, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS );
D3D12_RESOURCE_DESC uploadBufferDesc = CD3DX12_RESOURCE_DESC::Buffer( volumeBufferSize );
VRET( m_device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES( D3D12_HEAP_TYPE_DEFAULT ),D3D12_HEAP_FLAG_NONE,
&bufferDesc,D3D12_RESOURCE_STATE_COPY_DEST,nullptr,IID_PPV_ARGS( &m_volumeBuffer ) ) );
const UINT64 uploadBufferSize = GetRequiredIntermediateSize( m_volumeBuffer.Get(), 0, 1 );
// Create the GPU upload buffer.
VRET( m_device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES( D3D12_HEAP_TYPE_UPLOAD ),D3D12_HEAP_FLAG_NONE,
&uploadBufferDesc,D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr,IID_PPV_ARGS( &volumeBufferUploadHeap ) ) );
// Copy data to the intermediate upload heap and then schedule a copy
// from the upload heap to the Texture2D.
UINT8* volumeBuffer = ( UINT8* ) malloc( volumeBufferSize );
memset( volumeBuffer, 64, volumeBufferSize );
//float radius = m_volumeHeight / 2.f;
float a = m_volumeWidth / 2.f;
float b = m_volumeHeight / 2.f;
float c = m_volumeDepth / 2.f;
float radius = sqrt( a*a + b*b + c*c );
for ( UINT z = 0; z < m_volumeDepth; z++ )
for ( UINT y = 0; y < m_volumeHeight; y++ )
for ( UINT x = 0; x < m_volumeWidth; x++ )
{
float _x = x - m_volumeWidth / 2.f;
float _y = y - m_volumeHeight / 2.f;
float _z = z - m_volumeDepth / 2.f;
//float currentRaidus =abs(_x)+abs(_y)+abs(_z);
float currentRaidus = sqrt( _x*_x + _y*_y + _z*_z );
float scale = currentRaidus *3.f / radius;
UINT idx = 4 - (UINT)floor( scale );
UINT interm = ( UINT ) ( 192 * scale +0.5f );
UINT8 col = interm % 192+1;
volumeBuffer[( x + y*m_volumeWidth + z*m_volumeHeight*m_volumeWidth ) * 4 + 0] += col * m_constantBufferData.colVal[idx].x;
volumeBuffer[( x + y*m_volumeWidth + z*m_volumeHeight*m_volumeWidth ) * 4 + 1] += col * m_constantBufferData.colVal[idx].y;
volumeBuffer[( x + y*m_volumeWidth + z*m_volumeHeight*m_volumeWidth ) * 4 + 2] += col * m_constantBufferData.colVal[idx].z;
volumeBuffer[( x + y*m_volumeWidth + z*m_volumeHeight*m_volumeWidth ) * 4 + 3] = m_constantBufferData.colVal[idx].w;
}
D3D12_SUBRESOURCE_DATA volumeBufferData = {};
volumeBufferData.pData = &volumeBuffer[0];
volumeBufferData.RowPitch = volumeBufferSize;
volumeBufferData.SlicePitch = volumeBufferData.RowPitch;
UpdateSubresources( m_graphicCmdList.Get(), m_volumeBuffer.Get(), volumeBufferUploadHeap.Get(), 0, 0, 1, &volumeBufferData );
m_graphicCmdList->ResourceBarrier( 1, &CD3DX12_RESOURCE_BARRIER::Transition( m_volumeBuffer.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_UNORDERED_ACCESS ) );
// Describe and create a SRV for the volumeBuffer.
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
srvDesc.Format = DXGI_FORMAT_UNKNOWN;
srvDesc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
srvDesc.Buffer.FirstElement = 0;
srvDesc.Buffer.NumElements = m_volumeDepth*m_volumeHeight*m_volumeWidth;
srvDesc.Buffer.StructureByteStride = 4 * sizeof( UINT8 );
srvDesc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
CD3DX12_CPU_DESCRIPTOR_HANDLE srvHandle( m_cbvsrvuavHeap->GetCPUDescriptorHandleForHeapStart(), RootParameterSRV, m_cbvsrvuavDescriptorSize );
m_device->CreateShaderResourceView( m_volumeBuffer.Get(), &srvDesc, srvHandle );
// Describe and create a UAV for the volumeBuffer.
D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
uavDesc.Format = DXGI_FORMAT_UNKNOWN;
uavDesc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
uavDesc.Buffer.FirstElement = 0;
uavDesc.Buffer.NumElements = m_volumeWidth*m_volumeHeight*m_volumeDepth;
uavDesc.Buffer.StructureByteStride = 4 * sizeof( UINT8 );
uavDesc.Buffer.CounterOffsetInBytes = 0;
uavDesc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE;
CD3DX12_CPU_DESCRIPTOR_HANDLE uavHandle( m_cbvsrvuavHeap->GetCPUDescriptorHandleForHeapStart(), RootParameterUAV, m_cbvsrvuavDescriptorSize );
m_device->CreateUnorderedAccessView( m_volumeBuffer.Get(), nullptr, &uavDesc, uavHandle );
free( volumeBuffer );
}
// Create the vertex buffer.
// Note: ComPtr's are CPU objects but this resource needs to stay in scope until
// the command list that references it has finished executing on the GPU.
// We will flush the GPU at the end of this method to ensure the resource is not
// prematurely destroyed.
ComPtr<ID3D12Resource> vertexBufferUpload;
{
// Define the geometry for a triangle.
Vertex cubeVertices[] =
{
{ XMFLOAT3( -128.f, -128.f, -128.f ) },
{ XMFLOAT3( -128.f, -128.f, 128.f ) },
{ XMFLOAT3( -128.f, 128.f, -128.f ) },
{ XMFLOAT3( -128.f, 128.f, 128.f ) },
{ XMFLOAT3( 128.f, -128.f, -128.f )},
{ XMFLOAT3( 128.f, -128.f, 128.f )},
{ XMFLOAT3( 128.f, 128.f, -128.f )},
{ XMFLOAT3( 128.f, 128.f, 128.f )},
};
const UINT vertexBufferSize = sizeof( cubeVertices );
VRET( m_device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES( D3D12_HEAP_TYPE_UPLOAD ), D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer( vertexBufferSize ), D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr, IID_PPV_ARGS( &vertexBufferUpload ) ) );
VRET( m_device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES( D3D12_HEAP_TYPE_DEFAULT ), D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer( vertexBufferSize ), D3D12_RESOURCE_STATE_COPY_DEST,
nullptr, IID_PPV_ARGS( &m_vertexBuffer ) ) );
DXDebugName( m_vertexBuffer );
D3D12_SUBRESOURCE_DATA vertexData = {};
vertexData.pData = reinterpret_cast< UINT8* >( cubeVertices );
vertexData.RowPitch = vertexBufferSize;
vertexData.SlicePitch = vertexBufferSize;
UpdateSubresources<1>( m_graphicCmdList.Get(), m_vertexBuffer.Get(), vertexBufferUpload.Get(), 0, 0, 1, &vertexData );
m_graphicCmdList->ResourceBarrier( 1, &CD3DX12_RESOURCE_BARRIER::Transition( m_vertexBuffer.Get(), D3D12_RESOURCE_STATE_COPY_DEST,
D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER ));
// Initialize the vertex buffer view.
m_vertexBufferView.BufferLocation = m_vertexBuffer->GetGPUVirtualAddress();
m_vertexBufferView.StrideInBytes = sizeof( Vertex );
m_vertexBufferView.SizeInBytes = vertexBufferSize;
}
// Create the index buffer
// Note: ComPtr's are CPU objects but this resource needs to stay in scope until
// the command list that references it has finished executing on the GPU.
// We will flush the GPU at the end of this method to ensure the resource is not
// prematurely destroyed.
ComPtr<ID3D12Resource> indexBufferUpload;
{
uint16_t cubeIndices[] =
{
0,2,1, 1,2,3, 4,5,6, 5,7,6, 0,1,5, 0,5,4, 2,6,7, 2,7,3, 0,4,6, 0,6,2, 1,3,7, 1,7,5,
};
const UINT indexBufferSize = sizeof( cubeIndices );
VRET( m_device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES( D3D12_HEAP_TYPE_UPLOAD ), D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer( indexBufferSize ), D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr, IID_PPV_ARGS( &indexBufferUpload ) ) );
VRET( m_device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES( D3D12_HEAP_TYPE_DEFAULT ), D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer( indexBufferSize ), D3D12_RESOURCE_STATE_COPY_DEST,
nullptr, IID_PPV_ARGS( &m_indexBuffer ) ) );
DXDebugName( m_indexBuffer );
D3D12_SUBRESOURCE_DATA indexData = {};
indexData.pData = reinterpret_cast< UINT8* >( cubeIndices );
indexData.RowPitch = indexBufferSize;
indexData.SlicePitch = indexBufferSize;
UpdateSubresources<1>( m_graphicCmdList.Get(), m_indexBuffer.Get(), indexBufferUpload.Get(), 0, 0, 1, &indexData );
m_graphicCmdList->ResourceBarrier( 1, &CD3DX12_RESOURCE_BARRIER::Transition( m_indexBuffer.Get(), D3D12_RESOURCE_STATE_COPY_DEST,
D3D12_RESOURCE_STATE_INDEX_BUFFER ) );
m_indexBufferView.BufferLocation = m_indexBuffer->GetGPUVirtualAddress();
m_indexBufferView.SizeInBytes = sizeof( cubeIndices );
m_indexBufferView.Format = DXGI_FORMAT_R16_UINT;
}
// Create the constant buffer
{
VRET( m_device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES( D3D12_HEAP_TYPE_UPLOAD ), D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer( 1024 * 64 ), D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr, IID_PPV_ARGS( &m_constantBuffer ) ) );
DXDebugName( m_constantBuffer );
// Describe and create a constant buffer view.
D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc = {};
cbvDesc.BufferLocation = m_constantBuffer->GetGPUVirtualAddress();
cbvDesc.SizeInBytes = ( sizeof( ConstantBuffer ) + 255 ) & ~255; // CB size is required to be 256-byte aligned.
m_device->CreateConstantBufferView( &cbvDesc, m_cbvsrvuavHeap->GetCPUDescriptorHandleForHeapStart() );
// Initialize and map the constant buffers. We don't unmap this until the
// app closes. Keeping things mapped for the lifetime of the resource is okay.
CD3DX12_RANGE readRange( 0, 0 ); // We do not intend to read from this resource on the CPU.
VRET( m_constantBuffer->Map( 0, &readRange, reinterpret_cast< void** >( &m_pCbvDataBegin ) ) );
memcpy( m_pCbvDataBegin, &m_constantBufferData, sizeof( m_constantBufferData ) );
}
// Close the command list and execute it to begin the initial GPU setup.
VRET( m_graphicCmdList->Close() );
ID3D12CommandList* ppCommandLists[] = { m_graphicCmdList.Get() };
m_graphicCmdQueue->ExecuteCommandLists( _countof( ppCommandLists ), ppCommandLists );
// Create synchronization objects and wait until assets have been uploaded to the GPU.
{
VRET( m_device->CreateFence( 0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS( &m_fence ) ) );
DXDebugName( m_fence );
m_fenceValue = 1;
// Create an event handle to use for frame synchronization.
m_fenceEvent = CreateEvent( nullptr, FALSE, FALSE, nullptr );
if ( m_fenceEvent == nullptr )
{
VRET( HRESULT_FROM_WIN32( GetLastError() ) );
}
// Wait for the command list to execute; we are reusing the same command
// list in our main loop but for now, we just want to wait for setup to
// complete before continuing.
WaitForGraphicsCmd();
}
XMVECTORF32 vecEye = { 500.0f, 500.0f, -500.0f };
XMVECTORF32 vecAt = { 0.0f, 0.0f, 0.0f };
m_camera.SetViewParams( vecEye, vecAt );
m_camera.SetEnablePositionMovement( true );
m_camera.SetButtonMasks( MOUSE_RIGHT_BUTTON, MOUSE_WHEEL, MOUSE_LEFT_BUTTON );
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create the Resources
//--------------------------------------------------------------------------------------
HRESULT CreateResources()
{
HRESULT hr = S_OK;
ID3DBlob* pBlob = NULL;
// Compile the Bitonic Sort Compute Shader
hr = CompileShaderFromFile(L"ComputeShaderSort11.hlsl", "BitonicSort", "cs_4_0", &pBlob);
if (FAILED(hr))
return hr;
// Create the Bitonic Sort Compute Shader
hr = g_pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &g_pComputeShaderBitonic);
if (FAILED(hr))
return hr;
SAFE_RELEASE(pBlob);
#if defined(DEBUG) || defined(PROFILE)
g_pComputeShaderBitonic->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof("BitonicSort") - 1, "BitonicSort");
#endif
// Compile the Matrix Transpose Compute Shader
hr = CompileShaderFromFile(L"ComputeShaderSort11.hlsl", "MatrixTranspose", "cs_4_0", &pBlob);
if (FAILED(hr))
return hr;
// Create the Matrix Transpose Compute Shader
hr = g_pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &g_pComputeShaderTranspose);
if (FAILED(hr))
return hr;
SAFE_RELEASE(pBlob);
#if defined(DEBUG) || defined(PROFILE)
g_pComputeShaderTranspose->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof("MatrixTranspose") - 1, "MatrixTranspose");
#endif
// Create the Const Buffer
D3D11_BUFFER_DESC constant_buffer_desc;
ZeroMemory(&constant_buffer_desc, sizeof(constant_buffer_desc));
constant_buffer_desc.ByteWidth = sizeof(CB);
constant_buffer_desc.Usage = D3D11_USAGE_DEFAULT;
constant_buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
constant_buffer_desc.CPUAccessFlags = 0;
hr = g_pd3dDevice->CreateBuffer(&constant_buffer_desc, NULL, &g_pCB);
if (FAILED(hr))
return hr;
#if defined(DEBUG) || defined(PROFILE)
g_pCB->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof("CB") - 1, "CB");
#endif
// Create the Buffer of Elements
// Create 2 buffers for switching between when performing the transpose
D3D11_BUFFER_DESC buffer_desc;
ZeroMemory(&buffer_desc, sizeof(buffer_desc));
buffer_desc.ByteWidth = NUM_ELEMENTS * sizeof(UINT);
buffer_desc.Usage = D3D11_USAGE_DEFAULT;
buffer_desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
buffer_desc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
buffer_desc.StructureByteStride = sizeof(UINT);
hr = g_pd3dDevice->CreateBuffer(&buffer_desc, NULL, &g_pBuffer1);
if (FAILED(hr))
return hr;
#if defined(DEBUG) || defined(PROFILE)
g_pBuffer1->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof("Buffer1") - 1, "Buffer1");
#endif
hr = g_pd3dDevice->CreateBuffer(&buffer_desc, NULL, &g_pBuffer2);
if (FAILED(hr))
return hr;
#if defined(DEBUG) || defined(PROFILE)
g_pBuffer2->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof("Buffer2") - 1, "Buffer2");
#endif
// Create the Shader Resource View for the Buffers
// This is used for reading the buffer during the transpose
D3D11_SHADER_RESOURCE_VIEW_DESC srvbuffer_desc;
ZeroMemory(&srvbuffer_desc, sizeof(srvbuffer_desc));
srvbuffer_desc.Format = DXGI_FORMAT_UNKNOWN;
srvbuffer_desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
srvbuffer_desc.Buffer.ElementWidth = NUM_ELEMENTS;
hr = g_pd3dDevice->CreateShaderResourceView(g_pBuffer1, &srvbuffer_desc, &g_pBuffer1SRV);
if (FAILED(hr))
return hr;
#if defined(DEBUG) || defined(PROFILE)
g_pBuffer1SRV->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof("Buffer1 SRV") - 1, "Buffer1 SRV");
#endif
hr = g_pd3dDevice->CreateShaderResourceView(g_pBuffer2, &srvbuffer_desc, &g_pBuffer2SRV);
if (FAILED(hr))
return hr;
#if defined(DEBUG) || defined(PROFILE)
g_pBuffer2SRV->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof("Buffer2 SRV") - 1, "Buffer2 SRV");
#endif
// Create the Unordered Access View for the Buffers
// This is used for writing the buffer during the sort and transpose
D3D11_UNORDERED_ACCESS_VIEW_DESC uavbuffer_desc;
ZeroMemory(&uavbuffer_desc, sizeof(uavbuffer_desc));
uavbuffer_desc.Format = DXGI_FORMAT_UNKNOWN;
uavbuffer_desc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
uavbuffer_desc.Buffer.NumElements = NUM_ELEMENTS;
hr = g_pd3dDevice->CreateUnorderedAccessView(g_pBuffer1, &uavbuffer_desc, &g_pBuffer1UAV);
if (FAILED(hr))
return hr;
#if defined(DEBUG) || defined(PROFILE)
g_pBuffer1UAV->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof("Buffer1 UAV") - 1, "Buffer1 UAV");
#endif
hr = g_pd3dDevice->CreateUnorderedAccessView(g_pBuffer2, &uavbuffer_desc, &g_pBuffer2UAV);
if (FAILED(hr))
return hr;
#if defined(DEBUG) || defined(PROFILE)
g_pBuffer2UAV->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof("Buffer2 UAV") - 1, "Buffer2 UAV");
#endif
// Create the Readback Buffer
// This is used to read the results back to the CPU
D3D11_BUFFER_DESC readback_buffer_desc;
ZeroMemory(&readback_buffer_desc, sizeof(readback_buffer_desc));
readback_buffer_desc.ByteWidth = NUM_ELEMENTS * sizeof(UINT);
readback_buffer_desc.Usage = D3D11_USAGE_STAGING;
readback_buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
readback_buffer_desc.StructureByteStride = sizeof(UINT);
hr = g_pd3dDevice->CreateBuffer(&readback_buffer_desc, NULL, &g_pReadBackBuffer);
if (FAILED(hr))
return hr;
#if defined(DEBUG) || defined(PROFILE)
g_pReadBackBuffer->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof("ReadBack") - 1, "ReadBack");
#endif
return hr;
}
HRESULT InitDevice()
{
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;
sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
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 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"Tutorial05.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 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 28, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 36, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 48, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "BINORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 60, 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"Tutorial05.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;
// -------------------------------------------------------------
// JPE: Shaders para WireFrame
// -------------------------------------------------------------
// Compile the vertex shader
ID3DBlob* pVSBlobWF = NULL;
hr = CompileShaderFromFile(L"Tutorial05.fx", "VS_WF", "vs_4_0", &pVSBlobWF);
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(pVSBlobWF->GetBufferPointer(), pVSBlobWF->GetBufferSize(), NULL, &g_pVertexShaderWF);
pVSBlobWF->Release();
if (FAILED(hr))
return hr;
// Compile the pixel shader
ID3DBlob* pPSBlobWF = NULL;
hr = CompileShaderFromFile(L"Tutorial05.fx", "PS_WF", "ps_4_0", &pPSBlobWF);
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(pPSBlobWF->GetBufferPointer(), pPSBlobWF->GetBufferSize(), NULL, &g_pPixelShaderWF);
pPSBlobWF->Release();
if (FAILED(hr))
return hr;
// -------------------------------------------------------------
// JPE: Create vertex buffer and index buffer
SimpleVertex* vertices;
WORD* indices;
if (modelo == ModeloMono)
{
LoadFileOFF(&vertices, &indices, &cantVertices, &cantIndices);
}
else
{
LoadVertices(&vertices, &indices, &cantVertices, &cantIndices);
}
CalcularNormales(vertices, indices, cantVertices, cantIndices);
// Crea Buffer para Vertices
D3D11_BUFFER_DESC bd;
ZeroMemory( &bd, sizeof(bd) );
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( SimpleVertex ) * cantVertices;
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 );
// Crea Buffer para Indexes
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( WORD ) * cantIndices; // 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;
// JPE: Create the constant buffer for PixelShader
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(ConstantBufferPS);
bd.BindFlags = D3D11_BIND_SHADER_RESOURCE;
bd.CPUAccessFlags = 0;
hr = g_pd3dDevice->CreateBuffer(&bd, NULL, &g_pConstantBufferPS);
if (FAILED(hr))
return hr;
// Initialize the world matrix
g_World1 = XMMatrixIdentity();
g_World2 = XMMatrixIdentity();
SetViewMatrix();
// Initialize the projection matrix
g_Projection = XMMatrixPerspectiveFovLH( XM_PIDIV2, width / (FLOAT)height, 0.01f, 100.0f );
// JPE: Texturas
loadTextures(g_pd3dDevice);
// JPE: Raster state
///*
D3D11_RASTERIZER_DESC rasterDesc;
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
hr = g_pd3dDevice->CreateRasterizerState(&rasterDesc, &m_rasterState);
if (FAILED(hr))
{
return hr;
}
// Now set the rasterizer state.
g_pImmediateContext->RSSetState(m_rasterState);
//*/
// JPE: Raster state para WireFrame
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_WIREFRAME;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
hr = g_pd3dDevice->CreateRasterizerState(&rasterDesc, &m_rasterStateWF);
if (FAILED(hr))
{
return hr;
}
// JPE: Parametros default
if (modelo == ModeloMono)
{
bump = false;
useTexture = false;
rotate = false;
}
return S_OK;
}
//------------------------------------------------------------------------
int CGraphicsLayer::CreateShader()
{
HRESULT r=0;
DWORD ShaderFlags=D3D10_SHADER_ENABLE_STRICTNESS;
ID3D10Blob *pErrors = 0;
// Compile shaders
ID3D10Blob* pBlobVS = NULL;
ID3D10Blob* pBlobHS = NULL;
ID3D10Blob* pBlobDS = NULL;
ID3D10Blob* pBlobPS = NULL;
ID3D10Blob* pBlobGS = NULL;
ID3D10Blob* pBlobGSFur = NULL;
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "SmoothVS", "vs_5_0", &pBlobVS )!=S_OK){return 1;}
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "SmoothHS", "hs_5_0", &pBlobHS )!=S_OK){return 1;}
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "SmoothDS", "ds_5_0", &pBlobDS )!=S_OK){return 1;}
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "SmoothGS", "gs_5_0", &pBlobGS )!=S_OK){return 1;}
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "FurGS", "gs_5_0", &pBlobGSFur )!=S_OK){return 1;}
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "SmoothPS", "ps_5_0", &pBlobPS )!=S_OK){return 1;}
if(m_pDevice->CreateVertexShader( pBlobVS->GetBufferPointer(), pBlobVS->GetBufferSize(), NULL, &m_pVSGouraud )!=S_OK){return 1;}
if(m_pDevice->CreateHullShader( pBlobHS->GetBufferPointer(), pBlobHS->GetBufferSize(), NULL, &m_pHSSmooth )!=S_OK){return 1;}
if(m_pDevice->CreateDomainShader( pBlobDS->GetBufferPointer(), pBlobDS->GetBufferSize(), NULL, &m_pDSSmooth )!=S_OK){return 1;}
if(m_pDevice->CreateGeometryShader( pBlobGS->GetBufferPointer(), pBlobGS->GetBufferSize(), NULL, &m_pGSSmooth )!=S_OK){return 1;}
if(m_pDevice->CreatePixelShader( pBlobPS->GetBufferPointer(), pBlobPS->GetBufferSize(), NULL, &m_pPSGouraud )!=S_OK){return 1;}
if(m_pDevice->CreateGeometryShader( pBlobGSFur->GetBufferPointer(), pBlobGSFur->GetBufferSize(), NULL, &m_pGSFur )!=S_OK){return 1;}
D3D11_INPUT_ELEMENT_DESC defaultLayout[] =
{
{"POSITION",0,DXGI_FORMAT_R32G32B32_FLOAT ,0, 0,D3D11_INPUT_PER_VERTEX_DATA,0},
};
if(m_pDevice->CreateInputLayout( defaultLayout, ARRAYSIZE( defaultLayout ), pBlobVS->GetBufferPointer(),
pBlobVS->GetBufferSize(), &m_pVertexLayout )!=S_OK){return 1;}
m_pDeviceContext->IASetInputLayout(m_pVertexLayout);
if(CreateConstantsBuffer()!=S_OK){return 1;}
D3DXMATRIX mtxWorld;
D3DXMatrixIdentity(&mtxWorld);
SetWorldMtx(mtxWorld);
D3DXMATRIX mtxView;
D3DXVECTOR3 vecEye(3.0f, 3.0f, 3.5f);
D3DXVECTOR3 vecAt(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 vecUp(0.0f, 1.0f, 0.0f);
D3DXMatrixLookAtLH(&mtxView, &vecEye, &vecAt, &vecUp);
SetViewMtx(mtxView);
D3DXMatrixPerspectiveFovLH(&m_mProj, (float)D3DX_PI * 0.5f,
m_rcScreenRect.right/(float)m_rcScreenRect.bottom, 0.1f, 50.0f);
UpdateMatrices();
}
bool Shader::createShaders(const Microsoft::WRL::ComPtr<ID3D11Device> &pDevice
, const std::wstring &shaderFile, const std::string &vsFunc, const std::string &psFunc)
{
// vertex shader
{
Microsoft::WRL::ComPtr<ID3DBlob> vblob;
HRESULT hr = CompileShaderFromFile(shaderFile.c_str(), vsFunc.c_str(), "vs_4_0_level_9_1", &vblob);
if (FAILED(hr))
return false;
hr = pDevice->CreateVertexShader(vblob->GetBufferPointer(), vblob->GetBufferSize(), NULL, &m_pVsh);
if (FAILED(hr))
return false;
// vertex shader reflection
Microsoft::WRL::ComPtr<ID3D11ShaderReflection> pReflector;
hr = D3DReflect(vblob->GetBufferPointer(), vblob->GetBufferSize(), IID_ID3D11ShaderReflection, &pReflector);
if (FAILED(hr))
return false;
OutputDebugPrintfA("#### VertexShader ####\n");
if (!m_constant->Initialize(pDevice, SHADERSTAGE_VERTEX, pReflector)){
return false;
}
D3D11_SHADER_DESC shaderdesc;
pReflector->GetDesc(&shaderdesc);
// Create InputLayout
std::vector<D3D11_INPUT_ELEMENT_DESC> vbElement;
for (size_t i = 0; i < shaderdesc.InputParameters; ++i){
D3D11_SIGNATURE_PARAMETER_DESC sigdesc;
pReflector->GetInputParameterDesc(i, &sigdesc);
auto format = GetDxgiFormat(sigdesc.ComponentType, sigdesc.Mask);
D3D11_INPUT_ELEMENT_DESC eledesc = {
sigdesc.SemanticName
, sigdesc.SemanticIndex
, format
, 0 // 決め打ち
, D3D11_APPEND_ALIGNED_ELEMENT // 決め打ち
, D3D11_INPUT_PER_VERTEX_DATA // 決め打ち
, 0 // 決め打ち
};
vbElement.push_back(eledesc);
}
if (!vbElement.empty()){
hr = pDevice->CreateInputLayout(&vbElement[0], vbElement.size(),
vblob->GetBufferPointer(), vblob->GetBufferSize(), &m_pInputLayout);
if (FAILED(hr))
return false;
}
}
// pixel shader
{
Microsoft::WRL::ComPtr<ID3DBlob> pblob;
auto hr = CompileShaderFromFile(shaderFile.c_str(), psFunc.c_str(), "ps_4_0_level_9_1", &pblob);
if (FAILED(hr))
return false;
hr = pDevice->CreatePixelShader(pblob->GetBufferPointer(), pblob->GetBufferSize(), NULL, &m_pPsh);
if (FAILED(hr))
return false;
// pixel shader reflection
Microsoft::WRL::ComPtr<ID3D11ShaderReflection> pReflector;
hr = D3DReflect(pblob->GetBufferPointer(), pblob->GetBufferSize(), IID_ID3D11ShaderReflection,
&pReflector);
if (FAILED(hr))
return false;
OutputDebugPrintfA("#### PixelShader ####\n");
if (!m_constant->Initialize(pDevice, SHADERSTAGE_PIXEL, pReflector)){
return false;
}
}
return true;
}
// Create any D3D11 resources that aren't dependent on the back buffer
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN(gDialogResourceManager.OnD3D11CreateDevice(pd3dDevice, pd3dImmediateContext));
V_RETURN(gD3DSettingsDlg.OnD3D11CreateDevice(pd3dDevice));
gTxtHelper = new CDXUTTextHelper(pd3dDevice, pd3dImmediateContext, &gDialogResourceManager, 15);
// Create a vertex shader.
ID3DBlob* vertexShaderBuffer = NULL;
V_RETURN(CompileShaderFromFile(L"shaders.hlsl", "PassThroughVS", "vs_4_0", &vertexShaderBuffer));
V_RETURN(pd3dDevice->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &gVertexShader));
// Create a pixel shader that renders the composite frame.
ID3DBlob* pixelShaderBuffer = NULL;
V_RETURN(CompileShaderFromFile(L"shaders.hlsl", "RenderFramePS", "ps_4_0", &pixelShaderBuffer));
V_RETURN(pd3dDevice->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &gRenderFramePS));
// Create a pixel shader that renders the error texture.
V_RETURN(CompileShaderFromFile(L"shaders.hlsl", "RenderTexturePS", "ps_4_0", &pixelShaderBuffer));
V_RETURN(pd3dDevice->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &gRenderTexturePS));
// Create a pixel shader that shows alpha
V_RETURN(CompileShaderFromFile(L"shaders.hlsl", "RenderAlphaPS", "ps_4_0", &pixelShaderBuffer));
V_RETURN(pd3dDevice->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &gRenderAlphaPS));
// Create our vertex input layout
const D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
V_RETURN(pd3dDevice->CreateInputLayout(layout, ARRAYSIZE(layout), vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &gVertexLayout));
SAFE_RELEASE(vertexShaderBuffer);
SAFE_RELEASE(pixelShaderBuffer);
// Create a vertex buffer for three textured quads.
D3DXVECTOR2 quadSize(0.32f, 0.32f);
D3DXVECTOR2 quadOrigin(-0.66f, -0.0f);
Vertex tripleQuadVertices[18];
ZeroMemory(tripleQuadVertices, sizeof(tripleQuadVertices));
for(int i = 0; i < 18; i += 6)
{
tripleQuadVertices[i].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
tripleQuadVertices[i].texCoord = D3DXVECTOR2(0.0f, 0.0f);
tripleQuadVertices[i + 1].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
tripleQuadVertices[i + 1].texCoord = D3DXVECTOR2(1.0f, 0.0f);
tripleQuadVertices[i + 2].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
tripleQuadVertices[i + 2].texCoord = D3DXVECTOR2(1.0f, 1.0f);
tripleQuadVertices[i + 3].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
tripleQuadVertices[i + 3].texCoord = D3DXVECTOR2(1.0f, 1.0f);
tripleQuadVertices[i + 4].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
tripleQuadVertices[i + 4].texCoord = D3DXVECTOR2(0.0f, 1.0f);
tripleQuadVertices[i + 5].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
tripleQuadVertices[i + 5].texCoord = D3DXVECTOR2(0.0f, 0.0f);
quadOrigin.x += 0.66f;
}
D3D11_BUFFER_DESC bufDesc;
ZeroMemory(&bufDesc, sizeof(bufDesc));
bufDesc.Usage = D3D11_USAGE_DEFAULT;
bufDesc.ByteWidth = sizeof(tripleQuadVertices);
bufDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufDesc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA data;
ZeroMemory(&data, sizeof(data));
data.pSysMem = tripleQuadVertices;
V_RETURN(pd3dDevice->CreateBuffer(&bufDesc, &data, &gVertexBuffer));
// Create a vertex buffer for a single textured quad.
quadSize = D3DXVECTOR2(1.0f, 1.0f);
quadOrigin = D3DXVECTOR2(0.0f, 0.0f);
Vertex singleQuadVertices[6];
singleQuadVertices[0].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
singleQuadVertices[0].texCoord = D3DXVECTOR2(0.0f, 0.0f);
singleQuadVertices[1].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
singleQuadVertices[1].texCoord = D3DXVECTOR2(1.0f, 0.0f);
singleQuadVertices[2].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
singleQuadVertices[2].texCoord = D3DXVECTOR2(1.0f, 1.0f);
singleQuadVertices[3].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
singleQuadVertices[3].texCoord = D3DXVECTOR2(1.0f, 1.0f);
singleQuadVertices[4].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
singleQuadVertices[4].texCoord = D3DXVECTOR2(0.0f, 1.0f);
singleQuadVertices[5].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
singleQuadVertices[5].texCoord = D3DXVECTOR2(0.0f, 0.0f);
ZeroMemory(&bufDesc, sizeof(bufDesc));
bufDesc.Usage = D3D11_USAGE_DEFAULT;
bufDesc.ByteWidth = sizeof(singleQuadVertices);
bufDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufDesc.CPUAccessFlags = 0;
ZeroMemory(&data, sizeof(data));
data.pSysMem = singleQuadVertices;
V_RETURN(pd3dDevice->CreateBuffer(&bufDesc, &data, &gQuadVB));
// Create a constant buffer
ZeroMemory(&bufDesc, sizeof(bufDesc));
bufDesc.ByteWidth = sizeof( VS_CONSTANT_BUFFER );
bufDesc.Usage = D3D11_USAGE_DYNAMIC;
bufDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bufDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
V_RETURN(pd3dDevice->CreateBuffer(&bufDesc, NULL, &gConstantBuffer));
// Create a sampler state
D3D11_SAMPLER_DESC SamDesc;
SamDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
SamDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.MipLODBias = 0.0f;
SamDesc.MaxAnisotropy = 1;
SamDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
SamDesc.BorderColor[0] = SamDesc.BorderColor[1] = SamDesc.BorderColor[2] = SamDesc.BorderColor[3] = 0;
SamDesc.MinLOD = 0;
SamDesc.MaxLOD = D3D11_FLOAT32_MAX;
V_RETURN(pd3dDevice->CreateSamplerState(&SamDesc, &gSamPoint));
// Load and initialize the textures.
WCHAR path[MAX_PATH];
V_RETURN(DXUTFindDXSDKMediaFileCch(path, MAX_PATH, L"Images\\Desk_21_hdr.dds"));
V_RETURN(CreateTextures(path));
// Update the UI's texture width and height.
gSampleUI.SendEvent(IDC_TEXT, true, gSampleUI.GetStatic(IDC_TEXT));
return S_OK;
}
HRESULT CSkybox11::OnD3D11CreateDevice( ID3D11Device* pd3dDevice, float fSize,
ID3D11Texture2D* pCubeTexture, ID3D11ShaderResourceView* pCubeRV )
{
HRESULT hr;
m_pd3dDevice11 = pd3dDevice;
m_fSize = fSize;
m_pEnvironmentMap11 = pCubeTexture;
m_pEnvironmentRV11 = pCubeRV;
ID3DBlob* pBlobVS = NULL;
ID3DBlob* pBlobPS = NULL;
// Create the shaders
tstring filePath = GetFilePath::GetFilePath(_T("skybox.hlsl"));
// V_RETURN( CompileShaderFromFile( L"skybox11.hlsl", "SkyboxVS", "vs_4_0", &pBlobVS ) );
// V_RETURN( CompileShaderFromFile( L"skybox11.hlsl", "SkyboxPS", "ps_4_0", &pBlobPS ) );
V_RETURN( CompileShaderFromFile( (WCHAR *)filePath.c_str(), "SkyboxVS", "vs_4_0", &pBlobVS ) );
V_RETURN( CompileShaderFromFile( (WCHAR *)filePath.c_str(), "SkyboxPS", "ps_4_0", &pBlobPS ) );
V_RETURN( pd3dDevice->CreateVertexShader( pBlobVS->GetBufferPointer(), pBlobVS->GetBufferSize(), NULL, &m_pVertexShader ) );
V_RETURN( pd3dDevice->CreatePixelShader( pBlobPS->GetBufferPointer(), pBlobPS->GetBufferSize(), NULL, &m_pPixelShader ) );
// Create an input layout
V_RETURN( pd3dDevice->CreateInputLayout( g_aVertexLayout, 1, pBlobVS->GetBufferPointer(),
pBlobVS->GetBufferSize(), &m_pVertexLayout11 ) );
SAFE_RELEASE( pBlobVS );
SAFE_RELEASE( pBlobPS );
// Query support for linear filtering on DXGI_FORMAT_R32G32B32A32
UINT FormatSupport = 0;
V_RETURN( pd3dDevice->CheckFormatSupport( DXGI_FORMAT_R32G32B32A32_FLOAT, &FormatSupport ) );
// Setup linear or point sampler according to the format Query result
D3D11_SAMPLER_DESC SamDesc;
SamDesc.Filter = ( FormatSupport & D3D11_FORMAT_SUPPORT_SHADER_SAMPLE ) > 0 ? D3D11_FILTER_MIN_MAG_MIP_LINEAR : D3D11_FILTER_MIN_MAG_MIP_POINT;
SamDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.MipLODBias = 0.0f;
SamDesc.MaxAnisotropy = 1;
SamDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
SamDesc.BorderColor[0] = SamDesc.BorderColor[1] = SamDesc.BorderColor[2] = SamDesc.BorderColor[3] = 0;
SamDesc.MinLOD = 0;
SamDesc.MaxLOD = 0;
V_RETURN( pd3dDevice->CreateSamplerState( &SamDesc, &m_pSam ) );
// Setup constant buffer
D3D11_BUFFER_DESC Desc;
Desc.Usage = D3D11_USAGE_DYNAMIC;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
Desc.MiscFlags = 0;
Desc.ByteWidth = sizeof( CB_VS_PER_OBJECT );
V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &m_pcbVSPerObject ) );
// Depth stencil state
D3D11_DEPTH_STENCIL_DESC DSDesc;
ZeroMemory( &DSDesc, sizeof( D3D11_DEPTH_STENCIL_DESC ) );
DSDesc.DepthEnable = FALSE;
DSDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
DSDesc.DepthFunc = D3D11_COMPARISON_LESS;
DSDesc.StencilEnable = FALSE;
V_RETURN( pd3dDevice->CreateDepthStencilState( &DSDesc, &m_pDepthStencilState11 ) );
return S_OK;
}
//--------------------------------------------------------------------------------------
// Создание буфера вершин, шейдеров (shaders) и описания формата вершин (input layout)
//--------------------------------------------------------------------------------------
HRESULT InitGeometry()
{
HRESULT hr = S_OK;
// Компиляция вершинного шейдера из файла
ID3DBlob* pVSBlob = NULL; // Вспомогательный объект - просто место в оперативной памяти
hr = CompileShaderFromFile( "Urok2.fx", "VS", "vs_4_0", &pVSBlob );
if (FAILED(hr))
{
MessageBox( NULL, "Невозможно скомпилировать файл FX. Пожалуйста, запустите данную программу из папки, содержащей файл FX.", "Ошибка", MB_OK );
return hr;
}
// Создание вершинного шейдера
hr = g_pd3dDevice->CreateVertexShader( pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), NULL, &g_pVertexShader );
if( FAILED( hr ) )
{
pVSBlob->Release();
return hr;
}
// Определение шаблона вершин
// Вершины могут иметь различные параметры - координаты в пространстве, нормаль, цвет, координаты
// текстуры. Шаблон вершин указывает, какие именно параметры содержат вершины, которые мы собираемся
// использовать. Наши вершины (SimpleVertex) содержат только информацию о координатах в пространстве.
// Здесь же мы указываем вершинный шейдер, который будет использоваться для обработки информации о
// наших вершинах.
D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
/* семантическое имя, семантический индекс, размер, входящий слот (0-15), адрес начала данных
в буфере вершин, класс входящего слота (не важно), InstanceDataStepRate (не важно) */
};
UINT numElements = ARRAYSIZE( layout );
// Создание шаблона вершин
hr = g_pd3dDevice->CreateInputLayout( layout, numElements, pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(), &g_pVertexLayout );
pVSBlob->Release();
if (FAILED(hr)) return hr;
// Подключение шаблона вершин
g_pImmediateContext->IASetInputLayout( g_pVertexLayout );
// Компиляция пиксельного шейдера из файла
ID3DBlob* pPSBlob = NULL;
hr = CompileShaderFromFile("Urok2.fx", "PS", "ps_4_0", &pPSBlob);
if( FAILED( hr ) )
{
MessageBox( NULL, "Невозможно скомпилировать файл FX. Пожалуйста, запустите данную программу из папки, содержащей файл FX.", "Ошибка", MB_OK );
return hr;
}
// Создание пиксельного шейдера
hr = g_pd3dDevice->CreatePixelShader( pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), NULL, &g_pPixelShader );
pPSBlob->Release();
if (FAILED(hr)) return hr;
// Создание буфера вершин (три вершины треугольника)
SimpleVertex vertices[] = {
XMFLOAT3( 0.08f, -0.1f, 0.5f ),
XMFLOAT3( 0.0f, 0.0f, 0.5f ),
XMFLOAT3( 0.0f, 0.3f, 0.5f ),
XMFLOAT3( -0.08f, -0.1f, 0.5f )
//XMFLOAT3( -0.3f, -0.3f, 0.5f )
/*XMFLOAT3( -0.3f, 0.3f, 0.5f ),
XMFLOAT3( 0.3f, 0.3f, 0.5f ),
XMFLOAT3( -0.3f, -0.3f, 0.5f ),
XMFLOAT3( 0.3f, -0.3f, 0.5f ),
XMFLOAT3( 0.0f, -0.6f, 0.5f )*/
};
points = 4;
D3D11_BUFFER_DESC bd; // Структура, описывающая создаваемый буфер
ZeroMemory( &bd, sizeof(bd) ); // очищаем ее
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( SimpleVertex ) * points; // размер буфера
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER; // тип буфера - буфер вершин
bd.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA InitData; // Структура, содержащая данные буфера
ZeroMemory( &InitData, sizeof(InitData) ); // очищаем ее
InitData.pSysMem = vertices; // указатель на наши 3 вершины
// Вызов метода g_pd3dDevice создаст объект буфера вершин
hr = g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pVertexBuffer );
if (FAILED(hr)) return hr;
// Установка буфера вершин
UINT stride = sizeof( SimpleVertex );
UINT offset = 0;
g_pImmediateContext->IASetVertexBuffers( 0, 1, &g_pVertexBuffer, &stride, &offset );
// Установка способа отрисовки вершин в буфере (в данном случае - TRIANGLE LIST,
// т. е. точки 1-3 - первый треугольник, 4-6 - второй и т. д. Другой способ - TRIANGLE STRIP.
// В этом случае точки 1-3 - первый треугольник, 2-4 - второй, 3-5 - третий и т. д.
// В этом примере есть только один треугольник, поэтому способ отрисовки не имеет значения.
g_pImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP );
return S_OK;
}
HRESULT Application::InitShadersAndInputLayout()
{
HRESULT hr;
// Compile the vertex shader
ID3DBlob* pVSBlob = nullptr;
hr = CompileShaderFromFile(L"DX11 Framework.fx", "VS", "vs_4_0", &pVSBlob);
if (FAILED(hr))
{
MessageBox(nullptr,
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 = _pd3dDevice->CreateVertexShader(pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), nullptr, &_pVertexShader);
if (FAILED(hr))
{
pVSBlob->Release();
return hr;
}
// Compile the pixel shader
ID3DBlob* pPSBlob = nullptr;
hr = CompileShaderFromFile(L"DX11 Framework.fx", "PS", "ps_4_0", &pPSBlob);
if (FAILED(hr))
{
MessageBox(nullptr,
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 = _pd3dDevice->CreatePixelShader(pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), nullptr, &_pPixelShader);
pPSBlob->Release();
if (FAILED(hr))
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 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
// Lighting
// Light direction from surface (XYZ)
_light.mLightVecW = XMFLOAT3(5.25f, 1.0f, -1.0f);
// Diffuse lighting properties (RGBA)
_light.mDiffuseMtrl = XMFLOAT4(0.8f, 0.5f, 0.5f, 1.0f);
_light.mDiffuseLight = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
// Ambient lighting properties (RGBA)
_light.mAmbientMtrl = XMFLOAT3(0.2f, 0.2f, 0.2f);
_light.mAmbientLight = XMFLOAT3(0.2f, 0.2f, 0.2f);
// Specular lighting properties (RGBA)
//_light.mSpecularMtrl = XMFLOAT4(0.8f, 0.8f, 0.8f, 1.0f);
//_light.mSpecularLight = XMFLOAT4(0.5f, 0.5f, 0.5f, 1.0f);
//_light.mSpecularPower = 5.0f;
UINT numElements = ARRAYSIZE(layout);
// Create the input layout
hr = _pd3dDevice->CreateInputLayout(layout, numElements, pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(), &_pVertexLayout);
pVSBlob->Release();
if (FAILED(hr))
return hr;
// Set the input layout
_pImmediateContext->IASetInputLayout(_pVertexLayout);
return hr;
}
HRESULT DX11QuadDrawer::OnD3D11CreateDevice( ID3D11Device* pd3dDevice )
{
HRESULT hr = S_OK;
ID3DBlob* pBlob = NULL;
V_RETURN(CompileShaderFromFile(L"Shaders/QuadDrawer.hlsl", "QuadVS", "vs_5_0", &pBlob));
V_RETURN(pd3dDevice->CreateVertexShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_VertexShader));
D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = sizeof( layout ) / sizeof( layout[0] );
V_RETURN(pd3dDevice->CreateInputLayout(layout, numElements, pBlob->GetBufferPointer(), pBlob->GetBufferSize(), &s_VertexLayout));
SAFE_RELEASE(pBlob);
V_RETURN(CompileShaderFromFile(L"Shaders/QuadDrawer.hlsl", "QuadFloatPS", "ps_5_0", &pBlob));
V_RETURN(pd3dDevice->CreatePixelShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_PixelShaderFloat));
SAFE_RELEASE(pBlob);
V_RETURN(CompileShaderFromFile(L"Shaders/QuadDrawer.hlsl", "QuadRGBAPS", "ps_5_0", &pBlob));
V_RETURN(pd3dDevice->CreatePixelShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_PixelShaderRGBA));
SAFE_RELEASE(pBlob);
//V_RETURN(CompileShaderFromFile(L"QuadDrawer.hlsl", "QuadPS2", "ps_5_0", &pBlob));
//V_RETURN(pd3dDevice->CreatePixelShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &m_PixelShader2));
//SAFE_RELEASE(pBlob);
//V_RETURN(CompileShaderFromFile(L"Float4Pyramid.hlsl", "QuadPS3", "ps_5_0", &pBlob));
//V_RETURN(pd3dDevice->CreatePixelShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &s_PixelShader3));
//SAFE_RELEASE(pBlob);
SimpleVertex vertices[] =
{
{ float3( -1.0f, -1.0f, 0.0f ), float2( 0.0f, 1.0f ) },
{ float3( 1.0f, -1.0f, 0.0f ), float2( 1.0f, 1.0f ) },
{ float3( 1.0f, 1.0f, 0.0f ), float2( 1.0f, 0.0f ) },
{ float3( -1.0f, 1.0f, 0.0f ), float2( 0.0f, 0.0f ) }
};
D3D11_BUFFER_DESC desc;
ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
desc.Usage = D3D11_USAGE_IMMUTABLE;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.ByteWidth = sizeof(SimpleVertex) * 4;
D3D11_SUBRESOURCE_DATA InitData;
ZeroMemory( &InitData, sizeof(InitData) );
InitData.pSysMem = vertices;
V_RETURN( pd3dDevice->CreateBuffer( &desc, &InitData, &s_VertexBuffer ) );
ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0;
desc.ByteWidth = sizeof( CB_QUAD );
V_RETURN( pd3dDevice->CreateBuffer( &desc, NULL, &s_CBquad ) );
// Create and set index buffer
DWORD indices[] =
{
2,1,0,//0,1,2,
0,3,2//2,3,0
};
desc.Usage = D3D11_USAGE_DEFAULT;
desc.ByteWidth = sizeof( DWORD ) * 6;
desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
InitData.pSysMem = indices;
V_RETURN(pd3dDevice->CreateBuffer( &desc, &InitData, &s_IndexBuffer ));
D3D11_SAMPLER_DESC sdesc;
ZeroMemory(&sdesc, sizeof(sdesc));
sdesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
sdesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
sdesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
sdesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
V_RETURN(pd3dDevice->CreateSamplerState(&sdesc, &s_PointSampler));
// constant buffers---------------------------------------------------------------------------
D3D11_BUFFER_DESC Desc;
ZeroMemory(&Desc, sizeof(D3D11_BUFFER_DESC));
Desc.Usage = D3D11_USAGE_DYNAMIC;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
Desc.MiscFlags = 0;
Desc.ByteWidth = sizeof( CB_POW_TWO_RATIOS );
V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &s_pcbVSPowTwoRatios ) );
//--------------------------------------------------------------------------------------------
return hr;
}
static __forceinline bool LOAD_PS(const std::string& DefineString, const char* name, FRAGMENTSHADER& fragment, ZZshProfile context)
{
bool flag = CompileShaderFromFile(fragment.program, DefineString, name, GL_FRAGMENT_SHADER);
fragment.set_context(context);
return flag;
}
HRESULT DX11MarchingCubesHashSDF::initialize( ID3D11Device* pd3dDevice )
{
HRESULT hr = S_OK;
ID3DBlob* pBlob = NULL;
char SDFBLOCKSIZE[5];
sprintf_s(SDFBLOCKSIZE, "%d", SDF_BLOCK_SIZE);
char HANDLECOLLISIONS[5];
sprintf_s(HANDLECOLLISIONS, "%d", GlobalAppState::getInstance().s_HANDLE_COLLISIONS);
D3D_SHADER_MACRO shaderDefines[] = { { "SDF_BLOCK_SIZE", SDFBLOCKSIZE }, {"HANDLE_COLLISIONS", HANDLECOLLISIONS }, { 0 } };
D3D_SHADER_MACRO shaderDefinesWithout[] = { { "SDF_BLOCK_SIZE", SDFBLOCKSIZE }, { 0 } };
D3D_SHADER_MACRO* validDefines = shaderDefines;
if(GlobalAppState::getInstance().s_HANDLE_COLLISIONS == 0)
{
validDefines = shaderDefinesWithout;
}
V_RETURN(CompileShaderFromFile(L"Shaders\\ExtractIsoSurfaceHashSDF.hlsl", "extractIsoSurfaceHashSDFCS", "cs_5_0", &pBlob, validDefines));
V_RETURN(pd3dDevice->CreateComputeShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &m_pComputeShader))
SAFE_RELEASE(pBlob);
D3D11_BUFFER_DESC bDesc;
bDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bDesc.Usage = D3D11_USAGE_DYNAMIC;
bDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bDesc.MiscFlags = 0;
bDesc.ByteWidth = sizeof(CBuffer);
V_RETURN(pd3dDevice->CreateBuffer(&bDesc, NULL, &m_constantBuffer));
// Create Append Buffer
ZeroMemory(&bDesc, sizeof(D3D11_BUFFER_DESC));
bDesc.BindFlags = D3D11_BIND_UNORDERED_ACCESS;
bDesc.Usage = D3D11_USAGE_DEFAULT;
bDesc.CPUAccessFlags = 0;
bDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
bDesc.ByteWidth = 2*3*sizeof(float3)*s_maxNumberOfTriangles;
bDesc.StructureByteStride = 2*3*sizeof(float3);
V_RETURN(pd3dDevice->CreateBuffer(&bDesc, NULL, &s_pTriangles));
D3D11_UNORDERED_ACCESS_VIEW_DESC UAVDesc;
ZeroMemory(&UAVDesc, sizeof(D3D11_UNORDERED_ACCESS_VIEW_DESC));
UAVDesc.Format = DXGI_FORMAT_UNKNOWN;
UAVDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
UAVDesc.Buffer.FirstElement = 0;
UAVDesc.Buffer.Flags = D3D11_BUFFER_UAV_FLAG_APPEND;
UAVDesc.Buffer.NumElements = s_maxNumberOfTriangles;
V_RETURN(pd3dDevice->CreateUnorderedAccessView(s_pTriangles, &UAVDesc, &s_pTrianglesUAV));
// Create Output Buffer CPU
bDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
bDesc.BindFlags = 0;
bDesc.Usage = D3D11_USAGE_STAGING;
V_RETURN(pd3dDevice->CreateBuffer(&bDesc, NULL, &s_pOutputFloatCPU));
// Create Output Buffer
ZeroMemory(&bDesc, sizeof(D3D11_BUFFER_DESC));
bDesc.BindFlags = 0;
bDesc.Usage = D3D11_USAGE_STAGING;
bDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
bDesc.MiscFlags = 0;
bDesc.ByteWidth = sizeof(int);
V_RETURN(pd3dDevice->CreateBuffer(&bDesc, NULL, &s_BuffCountTriangles));
return hr;
}
HRESULT InitDevice()
{
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,
};
UINT numDriverTypes = ARRAYSIZE(driverTypes);
D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_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(nullptr, g_driverType, nullptr, 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 = nullptr;
hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
if (FAILED(hr))
return hr;
hr = g_pd3dDevice->CreateRenderTargetView(pBackBuffer, nullptr, &g_pRenderTargetView);
pBackBuffer->Release();
if (FAILED(hr))
return hr;
// 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, nullptr, &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);
// If PREBUILD_SHADER is defined, then the shaders are compiled at build time.
// If PREBUILD_SHADER is not defined, the shaders are compiled at run time.
#pragma region Shader compilation logic
// Vertex shader
ID3DBlob* pVSBlob = nullptr;
#ifdef PREBUILD_SHADER
// Create the vertex shader from precompiled cso file.
hr = D3DReadFileToBlob(L"vs.cso", &pVSBlob);
if (SUCCEEDED(hr))
g_pd3dDevice->CreateVertexShader(
pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(),
nullptr,
&g_pVertexShader);
#else
// Compile the vertex shader
hr = CompileShaderFromFile(L"vs.fx", "VS", "vs_4_0", &pVSBlob);
if (FAILED(hr))
{
MessageBox(nullptr,
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(),
nullptr,
&g_pVertexShader);
#endif
if (FAILED(hr))
{
if (pVSBlob) 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 = nullptr;
#ifdef PREBUILD_SHADER
// Create the vertex shader from precompiled cso file.
hr = D3DReadFileToBlob(L"ps.cso", &pPSBlob);
if (SUCCEEDED(hr))
g_pd3dDevice->CreatePixelShader(
pPSBlob->GetBufferPointer(),
pPSBlob->GetBufferSize(),
nullptr,
&g_pPixelShader);
#else
hr = CompileShaderFromFile(L"ps.fx", "PS", "ps_4_0", &pPSBlob);
if (FAILED(hr))
{
MessageBox(nullptr,
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(),
nullptr,
&g_pPixelShader);
#endif
pPSBlob->Release();
if (FAILED(hr))
return hr;
#pragma endregion
// 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) },
};
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,
};
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(WORD) * 36; // 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, nullptr, &g_pConstantBuffer);
if (FAILED(hr))
return hr;
// Initialize the world matrix
g_World = XMMatrixIdentity();
// Initialize the view matrix
XMVECTOR Eye = XMVectorSet(0.0f, 0.0f, -3.0f, 0.0f);
XMVECTOR At = XMVectorSet(0.0f, 0.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;
}
HRESULT Application::InitShadersAndInputLayout()
{
HRESULT hr;
// Compile the vertex shader
ID3DBlob* pVSBlob = nullptr;
hr = CompileShaderFromFile(L"DX11 Framework.fx", "VS", "vs_4_0", &pVSBlob);
if (FAILED(hr))
{
MessageBox(nullptr,
L"The FX file cannot be compiled VS. Please run this executable from the directory that contains the FX file.", L"Error", MB_OK);
return hr;
}
// Create the vertex shader
hr = _pd3dDevice->CreateVertexShader(pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), nullptr, &_pVertexShader);
if (FAILED(hr))
{
pVSBlob->Release();
return hr;
}
// Compile the pixel shader
ID3DBlob* pPSBlob = nullptr;
hr = CompileShaderFromFile(L"DX11 Framework.fx", "PS", "ps_4_0", &pPSBlob);
if (FAILED(hr))
{
MessageBox(nullptr,
L"The FX file cannot be compiled PS. Please run this executable from the directory that contains the FX file.", L"Error", MB_OK);
return hr;
}
// Create the pixel shader
hr = _pd3dDevice->CreatePixelShader(pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), nullptr, &_pPixelShader);
pPSBlob->Release();
if (FAILED(hr))
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 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = ARRAYSIZE(layout);
// Create the input layout
hr = _pd3dDevice->CreateInputLayout(layout, numElements, pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(), &_pVertexLayout);
pVSBlob->Release();
if (FAILED(hr))
return hr;
// Set the input layout
_pImmediateContext->IASetInputLayout(_pVertexLayout);
return hr;
}
bool initDirectx()
{
//create direct3d device and the swap chain for it
HRESULT hr = S_OK;
RECT rc = { 0, 0, 1280, 800 };
//get dimensions of the window
GetClientRect(g_hWnd, &rc);
UINT width = rc.right - rc.left;
UINT height = rc.bottom - rc.top;
UINT createDeviceFlags = 0;
//swapchain stuff
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;
D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
};
UINT numFeatureLevels = ARRAYSIZE(featureLevels);
//create the device and swap chain command does what it says it does
hr = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, featureLevels, numFeatureLevels,
D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext);
//make 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 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 out of the depth stencil texture
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);
//that's pretty much everything needed to create the device and other stuff to make it work
//now we gotta make the shaders
//compile vertex shader
ID3DBlob* pVSBlob = NULL;
hr = CompileShaderFromFile("shader.fx", "VS", "vs_4_0", &pVSBlob); //this function is from one of microsoft's directx 11 demos, it just makes stuff easier
if (FAILED(hr))
{
MessageBox(NULL, "The fx file didn't compile, run this application in the location with the fx file", "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 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, 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("shader.fx", "PS", "ps_5_0", &pPSBlob);
if (FAILED(hr))
{
MessageBox(NULL,
"The FX file cannot be compiled. Please run this executable from the directory that contains the FX file.", "Error", MB_OK);
return hr;
}
hr = g_pd3dDevice->CreatePixelShader(pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), NULL, &g_pPixelShader);
pPSBlob->Release();
if (FAILED(hr))
return hr;
//make the sphere model
std::vector<XMFLOAT3> verts;
std::vector<WORD> indices;
std::vector<XMFLOAT2> uvs;
CreateSphere(1.0f, 100, 100, &verts, &indices, &uvs);
num_sphere_indices = indices.size();
Vertex* Vertices = static_cast<Vertex*>(std::malloc(verts.size() * sizeof(Vertex))); //this is some of the data we will pass to the Directx 11 machine to make the vertex buffer
for (int i = 0; i < verts.size(); i++)
{
Vertex v;
v.Pos = verts[i];
XMVECTOR n = XMLoadFloat3(&verts[i]);
XMStoreFloat3(&v.Norm, XMVector3Normalize(n));
Vertices[i] = v;
}
WORD* Indices = static_cast<WORD*>(std::malloc(indices.size() * sizeof(WORD))); //this is some of the data we will pass to the Directx 11 machine to make the index buffer
for (int i = 0; i < indices.size(); i++)
{
Indices[i] = indices[i];
}
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(Vertex) * verts.size();
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);
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(WORD) * indices.size();
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
InitData.pSysMem = Indices;
g_pd3dDevice->CreateBuffer(&bd, &InitData, &g_pIndexBuffer);
free(Vertices);
free(Indices);
// Set vertex buffer
UINT stride = sizeof(Vertex);
UINT offset = 0;
g_pImmediateContext->IASetVertexBuffers(0, 1, &g_pVertexBuffer, &stride, &offset);
// 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(cBufferShader1);
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.CPUAccessFlags = 0;
hr = g_pd3dDevice->CreateBuffer(&bd, NULL, &g_pcBufferShader1);
if (FAILED(hr))
return hr;
// Initialize the view matrix
XMVECTOR Eye = XMVectorSet(0.0f, 5.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_PIDIV4, width / (FLOAT)height, 0.01f, 1000.0f);
return true;
}
HRESULT InitOculusRiftObjects()
{
HRESULT hr = S_OK;
//画面に描画するための頂点バッファ
SimpleVertex verticesL[] = {
XMFLOAT3(-1, 1,0),XMFLOAT4(1,1,1,1),XMFLOAT2(0,0),//頂点1
XMFLOAT3( 1, 1,0),XMFLOAT4(1,1,1,1),XMFLOAT2(0.5,0),//頂点2
XMFLOAT3(-1,-1,0),XMFLOAT4(1,1,1,1),XMFLOAT2(0,1),//頂点3
XMFLOAT3( 1,-1,0),XMFLOAT4(1,1,1,1),XMFLOAT2(0.5,1),//頂点4
};
SimpleVertex verticesR[] = {
XMFLOAT3(-1, 1,0),XMFLOAT4(1,1,1,1),XMFLOAT2(0.5,0),//頂点1
XMFLOAT3( 1, 1,0),XMFLOAT4(1,1,1,1),XMFLOAT2(1,0),//頂点2
XMFLOAT3(-1,-1,0),XMFLOAT4(1,1,1,1),XMFLOAT2(0.5,1),//頂点3
XMFLOAT3( 1,-1,0),XMFLOAT4(1,1,1,1),XMFLOAT2(1,1),//頂点4
};
D3D11_BUFFER_DESC bd;
ZeroMemory( &bd, sizeof(bd) );
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( SimpleVertex ) * 4;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA InitData;
ZeroMemory( &InitData, sizeof(InitData) );
InitData.pSysMem = verticesL;
hr = g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pVertexBufferOculusL );
if( FAILED( hr ) )
return hr;
InitData.pSysMem = verticesR;
hr = g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pVertexBufferOculusR );
if( FAILED( hr ) )
return hr;
//レンダーターゲット用のテクスチャを作成する
D3D11_TEXTURE2D_DESC desc;
ZeroMemory( &desc, sizeof(desc) );
desc.Width = WIDTH;
desc.Height = HEIGHT;
desc.MipLevels = 1;
desc.ArraySize = 1;
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
//テクスチャを作成する
g_pd3dDevice->CreateTexture2D( &desc, NULL, &g_pTextureOculus );
//シェーダーリソースビュー作ることで描画元として使用出来る
g_pd3dDevice->CreateShaderResourceView( g_pTextureOculus, NULL, &g_pShaderResViewOculus );
//レンダーターゲットビューを作る
g_pd3dDevice->CreateRenderTargetView( g_pTextureOculus, NULL, &g_pRenderTargetViewOculus );
//ピクセルシェーダーをコンパイル
ID3DBlob* pPSBlob = NULL;
hr = CompileShaderFromFile("OculusRift.hlsl", "PS_OculusRift", "ps_4_0", &pPSBlob );
if( FAILED( hr ) )
{
MessageBox( NULL,"ピクセルシェーダーを読み込めませんでした。", "Error", MB_OK );
return hr;
}
//ピクセルシェーダーからピクセルシェーダのオブジェクトを作成
hr = g_pd3dDevice->CreatePixelShader( pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), NULL, &g_pPixelShaderOculus );
pPSBlob->Release();
if( FAILED( hr ) )
return hr;
// コンスタントバッファの作成
// ゆがませるピクセルシェーダー用の設定
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(OculusRiftSettings);
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.CPUAccessFlags = 0;
hr = g_pd3dDevice->CreateBuffer( &bd, NULL, &g_pConstantBufferOculus );
if( FAILED( hr ) )
return hr;
return hr;
}
