std::shared_ptr<SwapChain> Device::createSwapChain(const Window& window)
{
std::shared_ptr<SwapChain> swapChain;
IDXGIDevice* dxgiDevice = nullptr;
if (SUCCEEDED(m_device->QueryInterface<IDXGIDevice>(&dxgiDevice)))
{
IDXGIAdapter* adapter = nullptr;
if (SUCCEEDED(dxgiDevice->GetAdapter(&adapter)))
{
IDXGIFactory* dxgiFactory = nullptr;
if (SUCCEEDED(adapter->GetParent(__uuidof(IDXGIFactory), reinterpret_cast<void**>(&dxgiFactory))))
{
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = 1;
sd.BufferDesc.Width = window.getWidth();
sd.BufferDesc.Height = window.getHeight();
sd.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 0;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = window.getPlatformData()->getHandle();
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
IDXGISwapChain* nativeSwapChain = nullptr;
if (SUCCEEDED(dxgiFactory->CreateSwapChain(m_device, &sd, &nativeSwapChain)))
{
ID3D11Texture2D* backBufferTexture = nullptr;
if (SUCCEEDED(nativeSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&backBufferTexture))))
{
auto texture = std::make_shared<Texture2d>(backBufferTexture);
auto backBufferRenderCommandEncoder = createRenderCommandEncoder(1, &texture, nullptr, false);
swapChain = std::make_shared<SwapChain>(nativeSwapChain, backBufferRenderCommandEncoder);
}
dxgiFactory->Release();
}
adapter->Release();
}
}
dxgiDevice->Release();
}
return swapChain;
}
HRESULT ACD3D::Resize(UINT width, UINT height)
{
HRESULT hr;
//mata o anterior
SAFE_RELEASE(mpVpComponents[mActiveWnd]->pRenderTargetView);
SAFE_RELEASE(mpVpComponents[mActiveWnd]->pDepthStencilView);
#pragma region RESIZE BACKBUFFER
IDXGISwapChain* pSwapChain = mpVpComponents[mActiveWnd]->pSwapChain;
hr = pSwapChain->ResizeBuffers(1, width, height, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH);
if( FAILED( hr ) )
{
MessageBoxA(nullptr, "[ERROR] ResizeBuffer. Resize()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
#pragma endregion
#pragma region CREATE RENDERTARGETVIEW
//array de backbuffers, um pra cada janela
ID3D11Texture2D* pBackBuffer;
ID3D11RenderTargetView* pRenderTargetView;
hr = pSwapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), ( LPVOID* )&pBackBuffer );
if( FAILED( hr ) )
{
MessageBoxA(nullptr, "[ERROR] Create Buffer. Resize()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
hr = ACD3DGlobals::G_pD3dDevice->CreateRenderTargetView( pBackBuffer, nullptr, &pRenderTargetView );
if( FAILED( hr ) )
{
MessageBoxA(nullptr, "[ERROR] Create render target view. Resize()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
mpVpComponents[mActiveWnd]->pRenderTargetView = pRenderTargetView;
pBackBuffer->Release();
#pragma endregion
#pragma region CREATE DEPTHSTENCILVIEW
//cria outro com as novas configuracoes
ID3D11Texture2D* pDepthStencil;
ID3D11DepthStencilView* pDepthStencilView;
//define o stencil view
hr = ACD3DConfigurations::DefineDepthStencilView(ACD3DGlobals::G_pD3dDevice,
&pDepthStencil, &pDepthStencilView,
width, height);
if( FAILED( hr ) )
{
MessageBoxA(nullptr, "[ERROR] Create depth stencil view. Resize()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
mpVpComponents[mActiveWnd]->pDepthStencilView = pDepthStencilView;
pDepthStencil->Release();
#pragma endregion
#pragma region RESIZE VIEWPORT
mpVpComponents[mActiveWnd]->Viewport.Width = width;
mpVpComponents[mActiveWnd]->Viewport.Height = height;
#pragma endregion
//seta a viewport
ACD3DGlobals::G_pContext->RSSetViewports( 1, &mpVpComponents[mActiveWnd]->Viewport );
//seta o render target e o depthstencil
ACD3DGlobals::G_pContext->OMSetRenderTargets( 1, &pRenderTargetView, pDepthStencilView );
return AC_OK;
};
HRESULT ACD3D::AddViewport(HWND hWnd, BOOL enableVSync)
{
HRESULT hr;
VSyncEnable = enableVSync;
Log("Add viewport");
//cria o retangulo para renderizacao
RECT rc;
GetClientRect( hWnd, &rc );
UINT width = rc.right - rc.left;
UINT height = rc.bottom - rc.top;
//adiciona os objetos necessarios para cada vp
ACD3DVpComponents* vpComponent = new ACD3DVpComponents();
//pega o factory
IDXGIFactory* pDXGIFactory = ACD3DTools::GetDXGIFactory();
#pragma region CREATE SWAP CHAIN
IDXGISwapChain* pSwapChain;
//define o rendertargetview, define o buffer e coloca como backbuffer em cada swapchain
//cria os swpachains para cada janela
DXGI_SWAP_CHAIN_DESC scd;
SecureZeroMemory(&scd, sizeof(scd));
if (VSyncEnable)
scd = ACD3DConfigurations::DefineSwapShain(hWnd, width, height, ACD3DGlobals::G_Numerator, ACD3DGlobals::G_Denomerator); //ser form o vsync enable ele sincroniza a renderizacao com o refreshrate da tela
else
scd = ACD3DConfigurations::DefineSwapShain(hWnd, width, height, 60, 1); //senao ele usa direto os valores padroes isso pode gerar alguns artefatos MF
hr = pDXGIFactory->CreateSwapChain(ACD3DGlobals::G_pD3dDevice, &scd, &pSwapChain);
if( FAILED( hr ) )
{
MessageBoxA(nullptr, "[ERROR] Creating SwapChain. AddViewport()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
// Release the factory.
pDXGIFactory->Release();
pDXGIFactory = nullptr;
vpComponent->pSwapChain = pSwapChain;
#pragma endregion
#pragma region CREATE RENDERTARGETVIEW
//array de backbuffers, um pra cada janela
ID3D11Texture2D* pBackBuffer;
ID3D11RenderTargetView* pRenderTargetView;
hr = pSwapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), ( LPVOID* )&pBackBuffer );
if( FAILED( hr ) )
{
MessageBoxA(nullptr, "[ERROR] Create buffer. AddViewport()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
hr = ACD3DGlobals::G_pD3dDevice->CreateRenderTargetView( pBackBuffer, nullptr, &pRenderTargetView );
if( FAILED( hr ) )
{
MessageBoxA(nullptr, "[ERROR] Create render target. AddViewport()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
vpComponent->pRenderTargetView = pRenderTargetView;
pBackBuffer->Release();
#pragma endregion
#pragma region CREATE DEPTHSTENCILVIEW
ID3D11Texture2D* pDepthStencil;
ID3D11DepthStencilView* pDepthStencilView;
//define o stencil view
hr = ACD3DConfigurations::DefineDepthStencilView(ACD3DGlobals::G_pD3dDevice,
&pDepthStencil, &pDepthStencilView,
width, height);
if( FAILED( hr ) )
{
MessageBoxA(nullptr, "[ERROR] Create depth stencil view. AddViewport()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
vpComponent->pDepthStencilView = pDepthStencilView;
pDepthStencil->Release();
#pragma endregion
#pragma region CREATE VIEWPORT
D3D11_VIEWPORT vp;
ACD3DConfigurations::DefineViewPort(width, height, 0, 1, rc.left, rc.top, &vp);
vpComponent->Viewport = vp;
#pragma endregion
//inser o objeto no map
mpVpComponents.insert(std::pair<HWND, ACD3DVpComponents*>(hWnd, vpComponent));
//seta a viewport
ACD3DGlobals::G_pContext->RSSetViewports( 1, &vp );
//seta o render target e o depthstencil
ACD3DGlobals::G_pContext->OMSetRenderTargets( 1, &pRenderTargetView, pDepthStencilView );
SetActiveViewport(hWnd);
SetActiveRenderingViewport(hWnd);
return AC_OK;
};
// WinMain
int APIENTRY _tWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow )
{
HRESULT hr;
// ウィンドウクラスを登録
WNDCLASSEX wcex = {
sizeof( WNDCLASSEX ), // cbSize
CS_HREDRAW | CS_VREDRAW, // style
WndProc, // lpfnWndProc
0, // cbClsExtra
0, // cbWndExtra
hInstance, // hInstance
NULL, // hIcon
NULL, // hCursor
( HBRUSH )( COLOR_WINDOW + 1 ), // hbrBackGround
NULL, // lpszMenuName
g_className, // lpszClassName
NULL // hIconSm
};
if ( ! RegisterClassEx( &wcex ) )
{
MessageBox( NULL, _T( "失敗: RegisterClassEx()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "RegisterClassEx: ok\n" ) );
// ウィンドウサイズを計算
RECT r = { 0, 0, 800, 450 }; // 800x450 (16:9)
if ( ! AdjustWindowRect( &r, WS_OVERLAPPEDWINDOW, FALSE ) )
{
MessageBox( NULL, _T( "失敗: AdjustWindowRect()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "AdjustWindowRect: ok (%d, %d)－(%d, %d)\n" ), r.left, r.top, r.right, r.bottom );
// ウィンドウ生成
HWND hWnd;
hWnd = CreateWindow( g_className,
g_windowName,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
0,
r.right - r.left,
r.bottom - r.top,
NULL,
NULL,
hInstance,
NULL );
if ( hWnd == NULL )
{
MessageBox( NULL, _T( "失敗: CreateWindow()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "CreateWindow: ok\n" ) );
// ウィンドウ表示
ShowWindow(hWnd, nCmdShow);
dtprintf( _T( "ShowWindow: ok\n" ) );
// スワップチェイン設定
DXGI_SWAP_CHAIN_DESC scDesc = {
{
1280, // BufferDesc.Width
720, // BufferDesc.Height
{
60, // BufferDesc.RefreshRate.Numerator
1 // BufferDesc.RefreshRate.Denominator
},
DXGI_FORMAT_R16G16B16A16_FLOAT, // BufferDesc.Format
DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED, // BufferDesc.ScanlineOrdering
DXGI_MODE_SCALING_CENTERED // BufferDesc.Scaling
},
{
1, // SampleDesc.Count
0 // SampleDesc.Quality
},
DXGI_USAGE_RENDER_TARGET_OUTPUT, // BufferUsage
1, // BufferCount
hWnd, // OutputWindow
TRUE, // Windowed
DXGI_SWAP_EFFECT_DISCARD, // SwapEffect
DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH // Flags
};
// Direct3D11 デバイス・デバイスコンテキスト・スワップチェーンを生成
ID3D11Device * pDevice = NULL;
ID3D11DeviceContext * pDeviceContext = NULL;
IDXGISwapChain * pSwapChain = NULL;
D3D_FEATURE_LEVEL feature;
hr = D3D11CreateDeviceAndSwapChain( NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
0,
NULL,
0,
D3D11_SDK_VERSION,
&scDesc,
&pSwapChain,
&pDevice,
&feature,
&pDeviceContext );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: D3D11CreateDeviceAndSwapChain()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "D3D11CreateDeviceAndSwapChain: ok (pDevice: 0x%p, pDeviceContext: 0x%p, pSwapChain: 0x%p, feature: 0x%4x)\n" ),
pDevice,
pDeviceContext,
pSwapChain,
( int ) feature );
// バックバッファテクスチャを取得
ID3D11Texture2D * pBackBuffer = NULL;
hr = pSwapChain->GetBuffer( 0, __uuidof( pBackBuffer ), reinterpret_cast< void ** >( &pBackBuffer ) );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: IDXGISwapChain::GetBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "IDXGISwapChain::GetBuffer: ok (pBackBuffer: 0x%p)\n" ), pBackBuffer );
// レンダーターゲットビューを生成
ID3D11RenderTargetView * pRenderTargetView = NULL;
hr = pDevice->CreateRenderTargetView( pBackBuffer, NULL, &pRenderTargetView );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateRenderTargetView()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateRenderTargetView: ok (pRenderTargetView: 0x%p)\n" ), pRenderTargetView );
// デプス・ステンシルバッファとなるテクスチャを生成
D3D11_TEXTURE2D_DESC depthStencilBufferDesc = {
1280, // Width
720, // Height
1, // MipLevels
1, // ArraySize
DXGI_FORMAT_D32_FLOAT, // Format
{
1, // SampleDesc.Count
0 // SampleDesc.Quality
},
D3D11_USAGE_DEFAULT, // Usage
D3D11_BIND_DEPTH_STENCIL, // BindFlags
0, // CPUAccessFlags
0 // MiscFlags
};
ID3D11Texture2D * pDepthStencilBuffer = NULL;
hr = pDevice->CreateTexture2D( &depthStencilBufferDesc, NULL, &pDepthStencilBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateTexture2D()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateTexture2D: ok (pDepthStencilBuffer: 0x%p)\n" ), pDepthStencilBuffer );
// デプス・ステンシルビューを生成
ID3D11DepthStencilView * pDepthStencilView = NULL;
hr = pDevice->CreateDepthStencilView( pDepthStencilBuffer, NULL, &pDepthStencilView );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateDepthStencilView()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateDepthStencilView: ok (pDepthStencilView: 0x%p)\n" ), pDepthStencilView );
// レンダーターゲットビューとデプス・ステンシルビューをバインド
ID3D11RenderTargetView * pRenderTargetViews[] = { pRenderTargetView };
pDeviceContext->OMSetRenderTargets( 1, pRenderTargetViews, pDepthStencilView );
dtprintf( _T( "ID3D11DeviceContext::OMSetRenderTargets: ok\n" ) );
// バックバッファはもうここでは使わない
COM_SAFE_RELEASE( pBackBuffer );
// ビューポートをバインド
D3D11_VIEWPORT viewport = {
0.0f, // TopLeftX
0.0f, // TopLeftY
1280.0f, // Width
720.0f, // Height
0.0f, // MinDepth
1.0f // MaxDepth
};
pDeviceContext->RSSetViewports( 1, &viewport );
dtprintf( _T( "ID3D11DeviceContext::RSSetViewports: ok\n" ) );
// 頂点データ
float vertices[ 8 ][ 7 ] = {
// Xaxis Yaxis Zaxis 赤 緑 青 Alpha
{ -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f }, // 手前左上
{ 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f }, // 手前右上
{ 0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f }, // 手前右下
{ -0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f }, // 手前左下
{ -0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f }, // 奥左上
{ 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 1.0f, 1.0f }, // 奥右上
{ 0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f }, // 奥右下
{ -0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f } // 奥左下
};
// 頂点バッファを生成
D3D11_BUFFER_DESC vertexBufferDesc = {
sizeof( vertices ), // ByteWidth
D3D11_USAGE_DEFAULT, // Usage
D3D11_BIND_VERTEX_BUFFER, // BindFlags
0, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
D3D11_SUBRESOURCE_DATA vertexResourceData = { vertices };
ID3D11Buffer * pVertexBuffer = NULL;
hr = pDevice->CreateBuffer( &vertexBufferDesc, &vertexResourceData, &pVertexBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pVertexBuffer: 0x%p)\n" ), pVertexBuffer );
// 頂点バッファをバインド
UINT strides[] = { sizeof( float ) * 7 };
UINT offsets[] = { 0 };
pDeviceContext->IASetVertexBuffers( 0, 1, &pVertexBuffer, strides, offsets );
dtprintf( _T( "ID3D11DeviceContext::IASetVertexBuffers: ok\n" ) );
// インデックスデータ
unsigned int indices[] = { 0, 1, 2, 0, 2, 3, // 手前
4, 0, 3, 4, 3, 7, // 左
1, 5, 6, 1, 6, 2, // 右
0, 4, 5, 0, 5, 1, // 上
2, 6, 7, 2, 7, 3, // 下
5, 4, 7, 5, 7, 6
}; // 裏
// インデックスバッファを生成
D3D11_BUFFER_DESC indexBufferDesc = {
sizeof( indices ), // ByteWidth
D3D11_USAGE_DEFAULT, // Usage
D3D11_BIND_INDEX_BUFFER, // BindFlags
0, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
D3D11_SUBRESOURCE_DATA indexResourceData = { indices };
ID3D11Buffer * pIndexBuffer = NULL;
hr = pDevice->CreateBuffer( &indexBufferDesc, &indexResourceData, &pIndexBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pIndexBuffer: 0x%p)\n" ), pIndexBuffer );
// インデックスバッファをバインド
pDeviceContext->IASetIndexBuffer( pIndexBuffer, DXGI_FORMAT_R32_UINT, 0 );
dtprintf( _T( "ID3D11DeviceContext::IASetIndexBuffer: ok\n" ) );
// プリミティブタイプを設定
pDeviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
dtprintf( _T( "ID3D11DeviceContext::IASetPrimitiveTopology: ok\n" ) );
// 頂点シェーダ用の定数バッファを作成
D3D11_BUFFER_DESC VSConstantBufferDesc = {
sizeof( D3DXMATRIX ) * 3, // ByteWidth
D3D11_USAGE_DYNAMIC, // Usage
D3D11_BIND_CONSTANT_BUFFER, // BindFlags
D3D11_CPU_ACCESS_WRITE, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
ID3D11Buffer * pVSConstantBuffer = NULL;
hr = pDevice->CreateBuffer( &VSConstantBufferDesc, NULL, &pVSConstantBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pVSConstantBuffer: 0x%p)\n" ), pVSConstantBuffer );
// 定数バッファをバインド
pDeviceContext->VSSetConstantBuffers( 0, 1, &pVSConstantBuffer );
dtprintf( _T( "ID3D11DeviceContext::VSSetConstantBuffers: ok\n" ) );
// 頂点シェーダを作成
ID3D11VertexShader * pVertexShader = NULL;
hr = pDevice->CreateVertexShader( g_vs_perspective, sizeof( g_vs_perspective ), NULL, &pVertexShader );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateVertexShader()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateVertexShader: ok (pVertexShader: 0x%p)\n" ), pVertexShader );
// ピクセルシェーダを作成
ID3D11PixelShader * pPixelShader = NULL;
hr = pDevice->CreatePixelShader( g_ps_constant, sizeof( g_ps_constant ), NULL, &pPixelShader );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreatePixelShader()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreatePixelShader: ok (pPixelShader: 0x%p)\n" ), pPixelShader );
// シェーダをバインド
pDeviceContext->VSSetShader( pVertexShader, NULL, 0 );
dtprintf( _T( "ID3D11DeviceContext::VSSetShader: ok\n" ) );
pDeviceContext->PSSetShader( pPixelShader, NULL, 0 );
dtprintf( _T( "ID3D11DeviceContext::PSSetShader: ok\n" ) );
pDeviceContext->GSSetShader( NULL, NULL, 0 );
pDeviceContext->HSSetShader( NULL, NULL, 0 );
pDeviceContext->DSSetShader( NULL, NULL, 0 );
// 入力エレメント記述子
D3D11_INPUT_ELEMENT_DESC verticesDesc[] = {
{ "IN_POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "IN_COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, sizeof(float)*3, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
// 入力レイアウトを生成
ID3D11InputLayout * pInputLayout = NULL;
hr = pDevice->CreateInputLayout( verticesDesc, 2, g_vs_perspective, sizeof( g_vs_perspective ), &pInputLayout );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateInputLayout()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateInputLayout: ok (pInputLayout: 0x%p)\n" ), pInputLayout );
// 入力レイアウトをバインド
pDeviceContext->IASetInputLayout( pInputLayout );
dtprintf( _T( "ID3D11DeviceContext::IASetInputLayout: ok\n" ) );
// ラスタライザステートを生成
D3D11_RASTERIZER_DESC rasterizerStateDesc = {
D3D11_FILL_SOLID, // FillMode
// D3D11_FILL_WIREFRAME, // FillMode (ワイヤーフレーム表示)
D3D11_CULL_BACK, // CullMode
// D3D11_CULL_NONE, // CullMode (カリングなし)
FALSE, // FrontCounterClockwise
0, // DepthBias
0.0f, // DepthBiasClamp
0.0f, // SlopeScaledDepthBias
TRUE, // DepthClipEnable
FALSE, // ScissorEnable
FALSE, // MultisampleEnable
FALSE // AntialiasedLineEnable
};
ID3D11RasterizerState * pRasterizerState = NULL;
hr = pDevice->CreateRasterizerState( &rasterizerStateDesc, &pRasterizerState );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateRasterizerState()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateRasterizerState: ok (pRasterizerState: 0x%p)\n" ), pRasterizerState );
// ラスタライザステートをバインド
pDeviceContext->RSSetState( pRasterizerState );
dtprintf( _T( "ID3D11DeviceContext::RSSetState: ok\n" ) );
// デプス・ステンシルステートを生成
D3D11_DEPTH_STENCIL_DESC depthStencilStateDesc = {
TRUE, // DepthEnable
D3D11_DEPTH_WRITE_MASK_ALL, // DepthWriteMask
D3D11_COMPARISON_LESS, // DepthFunc
FALSE, // StencilEnable
D3D11_DEFAULT_STENCIL_READ_MASK, // StencilReadMask
D3D11_DEFAULT_STENCIL_WRITE_MASK, // StencilWriteMask
{
D3D11_STENCIL_OP_KEEP, // FrontFace.StencilFailOp
D3D11_STENCIL_OP_KEEP, // FrontFace.StencilDepthFailOp
D3D11_STENCIL_OP_KEEP, // FrontFace.StencilPassOp
D3D11_COMPARISON_ALWAYS // FrontFace.StencilFunc
},
{
D3D11_STENCIL_OP_KEEP, // BackFace.StencilFailOp
D3D11_STENCIL_OP_KEEP, // BackFace.StencilDepthFailOp
D3D11_STENCIL_OP_KEEP, // BackFace.StencilPassOp
D3D11_COMPARISON_ALWAYS // BackFace.StencilFunc
}
};
ID3D11DepthStencilState * pDepthStencilState = NULL;
hr = pDevice->CreateDepthStencilState( &depthStencilStateDesc, &pDepthStencilState );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateDepthStencilState()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateDepthStencilState: ok (pDepthStencilState: 0x%p)\n" ), pDepthStencilState );
// デプス・ステンシルステートをバインド
pDeviceContext->OMSetDepthStencilState( pDepthStencilState, 0 );
dtprintf( _T( "ID3D11DeviceContext::OMSetDepthStencilState: ok\n" ) );
MSG msg;
while ( 1 )
{
// メッセージを取得
if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
if ( msg.message == WM_QUIT )
{
dtprintf( _T( "PeekMessage: WM_QUIT\n" ) );
break;
}
// メッセージ処理
DispatchMessage( &msg );
}
else
{
HRESULT hr;
static unsigned int count = 0;
float theta = ( count++ / 200.0f ) * ( 3.141593f / 2.0f );
// World-View-Projection 行列をそれぞれ生成
D3DXMATRIX world, view, projection;
D3DXMatrixIdentity( &world );
const D3DXVECTOR3 eye( 1.8f * 1.414214f * -cosf( theta ), 1.8f, 1.8f * 1.414214f * sinf( theta ) );
const D3DXVECTOR3 at( 0.0f, 0.0f, 0.0f );
const D3DXVECTOR3 up( 0.0f, 1.0f, 0.0f );
D3DXMatrixLookAtRH( &view, &eye, &at, &up );
D3DXMatrixPerspectiveFovRH( &projection, 3.141593f / 4.0f, 1280.0f / 720.0f, 1.0f, 10000.0f );
// 頂点シェーダ用定数バッファへアクセス
D3D11_MAPPED_SUBRESOURCE mapped;
hr = pDeviceContext->Map( pVSConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped );
if ( SUCCEEDED( hr ) )
{
D3DXMATRIX * mapped_m = static_cast< D3DXMATRIX * >( mapped.pData );
mapped_m[0] = world;
mapped_m[1] = view;
mapped_m[2] = projection;
// 後始末
pDeviceContext->Unmap( pVSConstantBuffer, 0 );
}
// レンダーターゲットビューをクリア
const float clear[ 4 ] = { 0.0f, 0.0f, 0.3f, 1.0f }; // RGBA
pDeviceContext->ClearRenderTargetView( pRenderTargetView, clear );
// デプス・ステンシルビューをクリア
pDeviceContext->ClearDepthStencilView( pDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0 );
// 描画
pDeviceContext->DrawIndexed( 36, 0, 0 );
pSwapChain->Present( 1, 0 );
// ちょっとだけ待つ
Sleep( 5 );
}
}
// シェーダをアンバインド
pDeviceContext->VSSetShader( NULL, NULL, 0 );
pDeviceContext->PSSetShader( NULL, NULL, 0 );
// デバイス・リソース解放
COM_SAFE_RELEASE( pDepthStencilState );
COM_SAFE_RELEASE( pRasterizerState );
COM_SAFE_RELEASE( pInputLayout );
COM_SAFE_RELEASE( pPixelShader );
COM_SAFE_RELEASE( pVertexShader );
COM_SAFE_RELEASE( pVSConstantBuffer );
COM_SAFE_RELEASE( pIndexBuffer );
COM_SAFE_RELEASE( pVertexBuffer );
COM_SAFE_RELEASE( pDepthStencilView );
COM_SAFE_RELEASE( pDepthStencilBuffer );
COM_SAFE_RELEASE( pRenderTargetView );
COM_SAFE_RELEASE( pSwapChain );
COM_SAFE_RELEASE( pDeviceContext );
COM_SAFE_RELEASE( pDevice );
return msg.wParam;
}
HRESULT STDMETHODCALLTYPE CDXGISwapChainDWM::GetBuffer(UINT Buffer, REFIID riid, void **ppSurface)
{
return m_pSwapChain->GetBuffer(Buffer, riid, ppSurface);
}
bool D10State::init() {
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10CreateEffectFromMemory);
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10CreateStateBlock);
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10StateBlockMaskEnableAll);
if (pD3D10CreateEffectFromMemory == NULL
|| pD3D10CreateStateBlock == NULL
|| pD3D10StateBlockMaskEnableAll == NULL) {
ods("D3D10: Could not get handles for all required D3D10 state initialization functions");
return false;
}
HRESULT hr;
D3D10_STATE_BLOCK_MASK StateBlockMask;
ZeroMemory(&StateBlockMask, sizeof(StateBlockMask));
hr = pD3D10StateBlockMaskEnableAll(&StateBlockMask);
if (FAILED(hr)) {
ods("D3D10: D3D10StateBlockMaskEnableAll failed");
return false;
}
hr = pD3D10CreateStateBlock(pDevice, &StateBlockMask, &pOrigStateBlock);
if (FAILED(hr)) {
ods("D3D10: D3D10CreateStateBlock for pOrigStateBlock failed");
return false;
}
hr = pD3D10CreateStateBlock(pDevice, &StateBlockMask, &pMyStateBlock);
if (FAILED(hr)) {
ods("D3D10: D3D10CreateStateBlock for pMyStateBlock failed");
return false;
}
hr = pOrigStateBlock->Capture();
if (FAILED(hr)) {
ods("D3D10: Failed to store original state block during init");
return false;
}
ID3D10Texture2D *pBackBuffer = NULL;
hr = pSwapChain->GetBuffer(0, __uuidof(*pBackBuffer), (LPVOID*)&pBackBuffer);
if (FAILED(hr)) {
ods("D3D10: pSwapChain->GetBuffer failure!");
return false;
}
pDevice->ClearState();
D3D10_TEXTURE2D_DESC backBufferSurfaceDesc;
pBackBuffer->GetDesc(&backBufferSurfaceDesc);
ZeroMemory(&vp, sizeof(vp));
vp.Width = backBufferSurfaceDesc.Width;
vp.Height = backBufferSurfaceDesc.Height;
vp.MinDepth = 0;
vp.MaxDepth = 1;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
pDevice->RSSetViewports(1, &vp);
hr = pDevice->CreateRenderTargetView(pBackBuffer, NULL, &pRTV);
if (FAILED(hr)) {
ods("D3D10: pDevice->CreateRenderTargetView failed!");
return false;
}
pDevice->OMSetRenderTargets(1, &pRTV, NULL);
// Settings for an "over" operation.
// https://en.wikipedia.org/w/index.php?title=Alpha_compositing&oldid=580659153#Description
D3D10_BLEND_DESC blend;
ZeroMemory(&blend, sizeof(blend));
blend.BlendEnable[0] = TRUE;
blend.SrcBlend = D3D10_BLEND_ONE;
blend.DestBlend = D3D10_BLEND_INV_SRC_ALPHA;
blend.BlendOp = D3D10_BLEND_OP_ADD;
blend.SrcBlendAlpha = D3D10_BLEND_ONE;
blend.DestBlendAlpha = D3D10_BLEND_INV_SRC_ALPHA;
blend.BlendOpAlpha = D3D10_BLEND_OP_ADD;
blend.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL;
hr = pDevice->CreateBlendState(&blend, &pBlendState);
if (FAILED(hr)) {
ods("D3D10: pDevice->CreateBlendState failed!");
return false;
}
pDevice->OMSetBlendState(pBlendState, NULL, 0xffffffff);
hr = pD3D10CreateEffectFromMemory((void *) g_main, sizeof(g_main), 0, pDevice, NULL, &pEffect);
if (FAILED(hr)) {
ods("D3D10: D3D10CreateEffectFromMemory failed!");
return false;
}
pTechnique = pEffect->GetTechniqueByName("Render");
if (pTechnique == NULL) {
ods("D3D10: Could not get technique for name 'Render'");
return false;
}
pDiffuseTexture = pEffect->GetVariableByName("txDiffuse")->AsShaderResource();
if (pDiffuseTexture == NULL) {
ods("D3D10: Could not get variable by name 'txDiffuse'");
return false;
}
pTexture = NULL;
pSRView = NULL;
// Define the input layout
D3D10_INPUT_ELEMENT_DESC layout[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = sizeof(layout) / sizeof(layout[0]);
// Create the input layout
D3D10_PASS_DESC PassDesc;
hr = pTechnique->GetPassByIndex(0)->GetDesc(&PassDesc);
if (FAILED(hr)) {
ods("D3D10: Couldn't get pass description for technique");
return false;
}
hr = pDevice->CreateInputLayout(layout, numElements, PassDesc.pIAInputSignature, PassDesc.IAInputSignatureSize, &pVertexLayout);
if (FAILED(hr)) {
ods("D3D10: pDevice->CreateInputLayout failure!");
return false;
}
pDevice->IASetInputLayout(pVertexLayout);
D3D10_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D10_USAGE_DYNAMIC;
bd.ByteWidth = sizeof(SimpleVertex) * 4;
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
bd.MiscFlags = 0;
hr = pDevice->CreateBuffer(&bd, NULL, &pVertexBuffer);
if (FAILED(hr)) {
ods("D3D10: pDevice->CreateBuffer failure!");
return false;
}
DWORD indices[] = {
0,1,3,
1,2,3,
};
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = sizeof(DWORD) * 6;
bd.BindFlags = D3D10_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
D3D10_SUBRESOURCE_DATA InitData;
ZeroMemory(&InitData, sizeof(InitData));
InitData.pSysMem = indices;
hr = pDevice->CreateBuffer(&bd, &InitData, &pIndexBuffer);
if (FAILED(hr)) {
ods("D3D10: pDevice->CreateBuffer failure!");
return false;
}
// Set index buffer
pDevice->IASetIndexBuffer(pIndexBuffer, DXGI_FORMAT_R32_UINT, 0);
// Set primitive topology
pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
hr = pMyStateBlock->Capture();
if (FAILED(hr)) {
ods("D3D10: Failed to capture newly created state block");
return false;
}
hr = pOrigStateBlock->Apply();
if (FAILED(hr)) {
ods("D3D10: Failed to restore original state block during init");
return false;
}
pBackBuffer->Release();
return true;
}
HRESULT STDMETHODCALLTYPE SwapPresentHook(UINT syncInterval, UINT flags)
{
IDXGISwapChain *swap = (IDXGISwapChain*)this;
if(lpCurrentSwap == NULL && !bTargetAcquired)
{
lpCurrentSwap = swap;
SetupD3D11(swap);
bTargetAcquired = true;
}
if(lpCurrentSwap == swap)
{
ID3D11Device *device = NULL;
HRESULT chi;
if(SUCCEEDED(chi = swap->GetDevice(__uuidof(ID3D11Device), (void**)&device)))
{
if(!lpCurrentDevice)
{
lpCurrentDevice = device;
oldD3D11Release = GetVTable(device, (8/4));
newD3D11Release = ConvertClassProcToFarproc((CLASSPROC)&D3D11Override::DeviceReleaseHook);
SetVTable(device, (8/4), newD3D11Release);
}
ID3D11DeviceContext *context;
device->GetImmediateContext(&context);
if(!bHasTextures && bCapturing)
{
if(dxgiFormat)
{
if(!hwndReceiver)
hwndReceiver = FindWindow(RECEIVER_WINDOWCLASS, NULL);
if(hwndReceiver)
{
D3D11_TEXTURE2D_DESC texDesc;
ZeroMemory(&texDesc, sizeof(texDesc));
texDesc.Width = d3d11CaptureInfo.cx;
texDesc.Height = d3d11CaptureInfo.cy;
texDesc.MipLevels = 1;
texDesc.ArraySize = 1;
texDesc.Format = dxgiFormat;
texDesc.SampleDesc.Count = 1;
texDesc.Usage = D3D11_USAGE_STAGING;
texDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
bool bSuccess = true;
UINT pitch;
for(UINT i=0; i<2; i++)
{
HRESULT ching;
if(FAILED(ching = device->CreateTexture2D(&texDesc, NULL, &d3d11Textures[i])))
{
bSuccess = false;
break;
}
if(i == 0)
{
ID3D11Resource *resource;
if(FAILED(d3d11Textures[i]->QueryInterface(__uuidof(ID3D11Resource), (void**)&resource)))
{
bSuccess = false;
break;
}
D3D11_MAPPED_SUBRESOURCE map;
if(FAILED(context->Map(resource, 0, D3D11_MAP_READ, 0, &map)))
{
bSuccess = false;
break;
}
pitch = map.RowPitch;
context->Unmap(resource, 0);
resource->Release();
}
}
if(bSuccess)
{
d3d11CaptureInfo.mapID = InitializeSharedMemory(pitch*d3d11CaptureInfo.cy, &d3d11CaptureInfo.mapSize, ©Data, textureBuffers);
if(!d3d11CaptureInfo.mapID)
bSuccess = false;
}
if(bSuccess)
{
bHasTextures = true;
d3d11CaptureInfo.captureType = CAPTURETYPE_MEMORY;
d3d11CaptureInfo.hwndSender = hwndSender;
d3d11CaptureInfo.pitch = pitch;
d3d11CaptureInfo.bFlip = FALSE;
PostMessage(hwndReceiver, RECEIVER_NEWCAPTURE, 0, (LPARAM)&d3d11CaptureInfo);
}
else
{
for(UINT i=0; i<2; i++)
{
SafeRelease(d3d11Textures[i]);
if(textureBuffers[i])
{
free(textureBuffers[i]);
textureBuffers[i] = NULL;
}
}
}
}
}
}
if(bHasTextures)
{
if(bCapturing)
{
DWORD nextCapture = curCapture == 0 ? 1 : 0;
ID3D11Texture2D *texture = d3d11Textures[curCapture];
ID3D11Resource *backBuffer = NULL;
if(SUCCEEDED(swap->GetBuffer(0, IID_ID3D11Resource, (void**)&backBuffer)))
{
if(bIsMultisampled)
context->ResolveSubresource(texture, 0, backBuffer, 0, dxgiFormat);
else
context->CopyResource(texture, backBuffer);
backBuffer->Release();
ID3D11Texture2D *lastTexture = d3d11Textures[nextCapture];
ID3D11Resource *resource;
if(SUCCEEDED(lastTexture->QueryInterface(__uuidof(ID3D11Resource), (void**)&resource)))
{
D3D11_MAPPED_SUBRESOURCE map;
if(SUCCEEDED(context->Map(resource, 0, D3D11_MAP_READ, 0, &map)))
{
LPBYTE *pTextureBuffer = NULL;
int lastRendered = -1;
//under no circumstances do we -ever- allow a stall
if(WaitForSingleObject(textureMutexes[curCapture], 0) == WAIT_OBJECT_0)
lastRendered = (int)curCapture;
else if(WaitForSingleObject(textureMutexes[nextCapture], 0) == WAIT_OBJECT_0)
lastRendered = (int)nextCapture;
if(lastRendered != -1)
{
SSECopy(textureBuffers[lastRendered], map.pData, map.RowPitch*d3d11CaptureInfo.cy);
ReleaseMutex(textureMutexes[lastRendered]);
}
context->Unmap(resource, 0);
copyData->lastRendered = (UINT)lastRendered;
}
resource->Release();
}
}
curCapture = nextCapture;
}
else
ClearD3D11Data();
}
device->Release();
context->Release();
}
}
gi11swapPresent.Unhook();
HRESULT hRes = swap->Present(syncInterval, flags);
gi11swapPresent.Rehook();
return hRes;
}
//--------------------------------------------------------------------------------------
void CALLBACK OnD3D10FrameRender(ID3D10Device* pDev10, double fTime, float fElapsedTime, void* pUserContext)
{
HRESULT hr;
g_pCamManager->SyncToCameraUI(g_CameraUI);
//dont delete, used no only here
const DXGI_SURFACE_DESC *pBackBufferSurfaceDesc = DXUTGetDXGIBackBufferSurfaceDesc();
if( ShadowAlgorithm != OldShadowAlgorithm )
{
OldShadowAlgorithm = ShadowAlgorithm;
switch( ShadowAlgorithm )
{
case STANDARD_BP:
g_ABP.OnD3D10DestroyDevice();
break;
case BP_MSSM_KERNEL:
g_BPMSSMKernel.OnD3D10DestroyDevice();
break;
case STD_VSM:
g_StdVSM.OnD3D10DestroyDevice();
break;
case MIP_VSM:
g_MipVSM.OnD3D10DestroyDevice();
break;
case HIR_BP:
g_HBP.OnD3D10DestroyDevice();
break;
case BP_GI:
g_BPGI.OnD3D10DestroyDevice();
break;
case STD_PCSS:
g_PCSS.OnD3D10DestroyDevice();
break;
default:
break;
};
switch( ShadowAlgorithm )
{
case STANDARD_BP:
g_ABP.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
g_ABP.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext );
break;
case BP_MSSM_KERNEL:
g_BPMSSMKernel.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
g_BPMSSMKernel.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext );
break;
case STD_VSM:
g_StdVSM.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
g_StdVSM.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext );
break;
case MIP_VSM:
g_MipVSM.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
g_MipVSM.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext );
break;
case HIR_BP:
g_HBP.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
g_HBP.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext );
break;
case BP_GI:
g_BPGI.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
g_BPGI.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext );
break;
case STD_PCSS:
g_PCSS.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
g_PCSS.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext );
break;
default:
break;
};
}
//begin light and view pos management
{
static double old_fTime = 0.001;
fTime = old_fTime;
old_fTime += 0.02;
static double oldTime = 0;
static unsigned old_iSta = 0;
static double stop_time = 0;
static double total_stop_time = 0;
double tmp = fTime;
unsigned iSta = g_SampleUI.GetCheckBox(IDC_STATIC)->GetChecked();
if( 0 == old_iSta && 1 == iSta )//turn to be static
{
stop_time = fTime - total_stop_time;
}
if( 1 == iSta )
{
total_stop_time += ( fTime - oldTime );
fTime = stop_time;
}
if( 0 == iSta )
{
fTime -= total_stop_time;
}
old_iSta = iSta;
oldTime = tmp;
}//end light and view pos management
S3UTCamera& g_CameraRef = *(g_pCamManager->ActiveEye());
// compute view matrix
D3DXMATRIX mTmp, mWorldView, mWorldViewProj, mWorldViewInv;
D3DXMatrixInverse(&mTmp, NULL, g_CameraRef.GetWorldMatrix());
D3DXMatrixMultiply(&mWorldView, &mTmp, g_CameraRef.GetViewMatrix());
// correct near/far clip planes according to camera location
D3DXVECTOR3 vBox[2];
float fAspectRatio = pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height;
// clear depth and color
ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView();
pDev10->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0);
ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView();
if( g_D3DSettingsDlg.IsActive() )
{
g_D3DSettingsDlg.OnRender( fElapsedTime );
return;
}
Parameters para;
para.fLightZn = g_fCtrledLightZn;
float biases[15];
biases[0] = g_fDepthBiasObject0;
biases[1] = g_fDefaultDepthBias;
biases[2] = g_fDepthBiasHammer;
biases[3] = g_fDepthBiasLeftForearm;
biases[4] = g_fDepthBiasRightForearm;
biases[5] = g_fDepthBiasLeftShoulder;
biases[6] = g_fDepthBiasRightShoulder;
biases[7] = g_fDepthBiasBlackPlate;
biases[8] = g_fDepthBiasHelmet;
biases[9] = g_fDepthBiasEyes;
biases[10] = g_fDepthBiasBelt;
biases[11] = g_fDepthBiasLeftThigh;
biases[12] = g_fDepthBiasRightThigh;
biases[13] = g_fDepthBiasLeftShin;
biases[14] = g_fDepthBiasRightShin;
g_MeshScene.set_biases(biases,15);
float light_size[NUM_LIGHT] = LIGHT_SIZE;
float light_ZNS[NUM_LIGHT] = LIGHT_ZNS;
float light_view_angle[NUM_LIGHT] = LIGHT_VIEW_ANGLES;
D3DXVECTOR4 light_color[NUM_LIGHT] = LIGHT_COLOR;
bool render_ogre = g_SampleUI.GetCheckBox( IDC_ANIMATE )->GetChecked();
bool render_scene = g_SampleUI.GetCheckBox( IDC_SCENE )->GetChecked();
bool render_fan = g_SampleUI.GetCheckBox( IDC_FAN )->GetChecked();
float ClearColor[4] = { 0, 0, 0, 1 };
pDev10->ClearRenderTargetView(g_pBlendBuffer->m_pRTView, ClearColor);
//use alpha val 1 to represent untouched pixels
pDev10->ClearRenderTargetView(g_pWidgetBuffer->m_pRTView, ClearColor);
//light management
ID3D10RenderTargetView *p_RTV;
ID3D10ShaderResourceView *p_SRV;
static float light_scale_factor = 0.2;
static float ls_incre = 0.04;
if( g_LightVary == true || g_fFilterSize < g_fFilterSizeCtrl )
{
g_fFilterSize -= ls_incre;
if( g_fFilterSize < 0.1 || g_fFilterSize > g_fFilterSizeCtrl )
ls_incre = -ls_incre;
}
else
{
g_fFilterSize = g_fFilterSizeCtrl;
}
g_fFilterSize = g_fFilterSizeCtrl;
//light pos is not modified here. this light pos stored in 3DWidget is only synced with light camera after rendering of the light
//if you try to modify light pos here, light would be freezed, of course, this is a bug introduced by bad design
D3DXVECTOR3 vTmp;
// render GBuffer
pDev10->OMSetDepthStencilState(g_pDSState,0);
g_GBuffer.OnD3D10FrameRender( true, true, g_SampleUI,
g_MeshScene, g_CameraRef,
pDev10, fTime, fElapsedTime, pUserContext );
g_Blender.OriginalSampleMask = 0;
pDev10->OMGetBlendState( &g_Blender.pOriginalBlendState, g_Blender.OriginalBlendFactor, &g_Blender.OriginalSampleMask );
float BlendBufferClearColor[4] = { 1, 1, 0, 1 };
bool isFirstPass = true;
for( int cam_idx = 0; cam_idx < g_pCamManager->CameraCount(); ++cam_idx )
{
// rendering a subdivided light
if( g_pCamManager->Camera(cam_idx)->GetCamType() == S3UTCamera::eLight&&
g_pCamManager->Camera(cam_idx)->IsActive() )
{
float scaled_half_light_size = (g_pCamManager->Camera(cam_idx)->GetLightSize()*LIGHT_SCALE_FACTOR);
float fStartPt = -scaled_half_light_size;
float fInterval = 2 * scaled_half_light_size / g_nNumLightSample;
float fSubLightSize = g_pCamManager->Camera(cam_idx)->GetLightSize();
if( g_nNumLightSample > 0 )
{
fSubLightSize = fSubLightSize / g_nNumLightSample;
}
if( g_nNumLightSample == 0 )
{
g_nNumLightSample = 1;
}
static float total_light_x_incre = 0;
static int light_mov_dir = 0;
float shadow_factor = 0.8/(g_nNumLightSample * g_nNumLightSample);
for( int ix = 0; ix < g_nNumLightSample; ++ix )
{
for( int iy = 0; iy < g_nNumLightSample; ++iy )
{
D3DXVECTOR3 vLight = *g_pCamManager->Camera(cam_idx)->GetEyePt();
S3UTCamera local_cam = *g_pCamManager->Camera(cam_idx);
D3DXVECTOR3 vTrans( fStartPt+(ix+0.5)*fInterval,fStartPt+(iy+0.5)*fInterval,0 );
if( g_nNumLightSample == 1 )
{
vTrans = D3DXVECTOR3(0,0,0);
}
D3DXMATRIX mInvLightView;
D3DXVECTOR4 tmp_light_pos;
D3DXMatrixInverse(&mInvLightView, NULL, local_cam.GetViewMatrix());
D3DXVec3Transform(&tmp_light_pos, &vTrans, &mInvLightView );
D3DXVECTOR3 tmp_light_pos_3(tmp_light_pos.x,tmp_light_pos.y,tmp_light_pos.z);
D3DXVECTOR3 vLookAt = *local_cam.GetLookAtPt();
local_cam.SetViewParams( &tmp_light_pos_3, &vLookAt );
g_MeshScene.set_parameters( render_ogre, render_scene, render_fan, false );
D3DXMATRIX mLightView;
// here we compute light viewprojection so that light oversees the whole scene
D3DXMATRIX mTranslate;
D3DXMatrixInverse(&mTranslate, NULL, local_cam.GetWorldMatrix());
D3DXMatrixMultiply(&mLightView, &mTranslate, local_cam.GetViewMatrix());
unsigned iTmp = g_SampleUI.GetCheckBox(IDC_BDUMP_SHADOWMAP)->GetChecked();
ssmap.Render(pDev10, &g_MeshScene, local_cam,fTime,fElapsedTime,iTmp);
pDev10->RSSetState(g_pRenderState);
p_RTV = g_pBlendBuffer->m_pRTView;
float NewBlendFactor[4] = {0,0,0,0};
//alpha blending initial;
if( isFirstPass )
{
isFirstPass = false;
pDev10->OMSetBlendState( g_Blender.m_pSceneBlendStateInitial, NewBlendFactor, 0xffffffff );
}
else
{
pDev10->OMSetBlendState( g_Blender.m_pSceneBlendStateOn, NewBlendFactor, 0xffffffff );
}
if( ShadowAlgorithm == BP_GI )
{
V(g_BPGI.m_pEffect->GetVariableByName("g_fLumiFactor")->AsScalar()->SetFloat( shadow_factor ));
g_BPGI.set_parameters( para,p_RTV,&light_color[0] );
g_BPGI.set_input_buffer( &g_GBuffer );
g_BPGI.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext);
}
else if( ShadowAlgorithm == STANDARD_BP )
{
V(g_ABP.m_pEffect->GetVariableByName("fLumiFactor")->AsScalar()->SetFloat( shadow_factor ));
g_ABP.set_parameters( para,p_RTV,&light_color[0] );
g_ABP.set_input_buffer( &g_GBuffer );
g_ABP.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext);
}
else if( ShadowAlgorithm == BP_MSSM_KERNEL )
{
V(g_BPMSSMKernel.m_pEffect->GetVariableByName("fLumiFactor")->AsScalar()->SetFloat( shadow_factor ));
g_BPMSSMKernel.set_parameters( para,p_RTV,&light_color[0] );
g_BPMSSMKernel.set_input_buffer( &g_GBuffer );
g_BPMSSMKernel.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext);
}
else if( ShadowAlgorithm == STD_VSM )
{
V(g_StdVSM.m_pEffect->GetVariableByName("fLumiFactor")->AsScalar()->SetFloat( shadow_factor ));
g_StdVSM.set_bias( g_fDefaultDepthBias,g_f3rdDepthDelta, g_f1stDepthDelta );
g_StdVSM.set_parameters( para,p_RTV,&light_color[0] );
g_StdVSM.set_input_buffer( &g_GBuffer );
g_StdVSM.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext);
}
else if( ShadowAlgorithm == MIP_VSM )
{
V(g_MipVSM.m_pEffect->GetVariableByName("fLumiFactor")->AsScalar()->SetFloat( shadow_factor ));
g_MipVSM.set_parameters( para,p_RTV,&light_color[0] );
g_MipVSM.set_input_buffer( &g_GBuffer );
g_MipVSM.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext);
}
else if( ShadowAlgorithm == STD_PCSS )
{
V(g_PCSS.m_pEffect->GetVariableByName("fLumiFactor")->AsScalar()->SetFloat( shadow_factor ));
g_PCSS.set_parameters( para,p_RTV,&light_color[0] );
g_PCSS.set_input_buffer( &g_GBuffer );
g_PCSS.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext);
}
//alpha blending restore
pDev10->OMSetBlendState( g_Blender.pOriginalBlendState, g_Blender.OriginalBlendFactor, g_Blender.OriginalSampleMask );
if( g_SampleUI.GetCheckBox( IDC_SHOW_3DWIDGET )->GetChecked() )
{
if( g_pCamManager->Camera(cam_idx)->GetCamType() == S3UTCamera::eLight&&
g_pCamManager->Camera(cam_idx)->IsActive() )
{
pDev10->OMSetRenderTargets(1, &(g_pWidgetBuffer->m_pRTView), g_GBuffer.m_pDepthBuffer->m_pDSView);
g_Widget.m_pSsmap = &ssmap;
g_Widget.OnD3D10FrameRender(pDev10,g_CameraRef,local_cam);
}
}
}
}
}
}
//-----------------------------------------------------------------------------------
D3DXMATRIX mMatrixScale;
D3DXMATRIX mMatrixScaleWVP;
D3DXMatrixScaling( &mMatrixScale,(FLOAT)5,(FLOAT)5,(FLOAT)5 );
D3DXMatrixMultiply( &mMatrixScaleWVP, &mMatrixScale, &mWorldViewProj );
ID3D10RenderTargetView* pOrigRTV = DXUTGetD3D10RenderTargetView();
pDev10->OMSetRenderTargets(1,&pOrigRTV,NULL);
float FinalClearColor[4] = { 1, 0, 0, 1 };
pDev10->ClearRenderTargetView(pOrigRTV, FinalClearColor);
g_MeshScene.set_parameters( render_ogre,render_scene, render_fan );
g_Final.set_parameters( para, pOrigRTV, NULL, g_pBlendBuffer->m_pSRView, g_pWidgetBuffer->m_pSRView );
S3UTCamera& g_LCameraRef = g_LCamera[0];
g_Final.set_input_buffer( &g_GBuffer );
g_pSkyBox->OnFrameRender( mMatrixScaleWVP );
g_Final.OnD3D10FrameRender(g_SampleUI,g_MeshScene,g_fFilterSize,ssmap,g_CameraRef,g_LCameraRef,pDev10,fTime,fElapsedTime,pUserContext);
g_LCameraRef.SetProjParams(g_fCtrledLightFov, 1.0, g_fCtrledLightZn, g_fCtrledLightZf);
//if( g_SampleUI.GetCheckBox( IDC_SHOW_3DWIDGET )->GetChecked() )
//{
// for( int cam_idx = 0; cam_idx < g_pCamManager->CameraCount(); ++cam_idx )
// {
// // rendering a subdivided light
// if( g_pCamManager->Camera(cam_idx)->GetCamType() == S3UTCamera::eLight&&
// g_pCamManager->Camera(cam_idx)->IsActive() )
// {
// g_Widget.m_pSsmap = &ssmap;
// g_Widget.OnD3D10FrameRender(pDev10,g_CameraRef,*(g_pCamManager->Camera(cam_idx)));
// }
// }
//}
// render UI
if (g_bShowUI)
{
RenderText();
g_SampleUI.OnRender(fElapsedTime);
//g_HUD.OnRender(fElapsedTime);
}
if( g_bShowLightUI )
{
g_CameraUI.OnRender(fElapsedTime);
}
if( g_SampleUI.GetCheckBox( IDC_FRAME_DUMP )->GetChecked() )
{
static int g_Frame = 0;
IDXGISwapChain* pSwapChain = DXUTGetDXGISwapChain();
ID3D10Texture2D* pRT;
pSwapChain->GetBuffer(0, __uuidof(pRT), reinterpret_cast<void**>(&pRT));
WCHAR filename[32];
StringCchPrintf(filename, 100, L"DumpedImages\\screenshot%.3d.jpg", g_Frame);
D3DX10SaveTextureToFile(pRT, D3DX10_IFF_JPG, filename);
SAFE_RELEASE(pRT);
++g_Frame;
}
}
bool D11State::init() {
HRESULT hr;
ID3D11Texture2D* pBackBuffer = NULL;
hr = pSwapChain->GetBuffer(0, __uuidof(*pBackBuffer), (LPVOID*)&pBackBuffer);
if (FAILED(hr)) {
ods("D3D11: pSwapChain->GetBuffer failure!");
return false;
}
hr = pDevice->CreateDeferredContext(0, &pDeviceContext);
// Depending on the device settings a deferred context may not be createable
// for example if it is a SINGLETHREADED device.
// (See http://msdn.microsoft.com/en-us/library/windows/desktop/ff476505%28v=vs.85%29.aspx)
// We handle the expected failure and failure fallback in the same way -
// by trying to use an immediate context.
if (FAILED(hr) || !pDeviceContext) {
ods("D3D11: Failed to create DeferredContext (0x%x). Getting ImmediateContext", hr);
pDevice->GetImmediateContext(&pDeviceContext);
D11CreateStateBlock(pDeviceContext, &pOrigStateBlock);
D11CreateStateBlock(pDeviceContext, &pMyStateBlock);
pOrigStateBlock->Capture();
bDeferredContext = false;
} else {
bDeferredContext = true;
}
D3D11_TEXTURE2D_DESC backBufferSurfaceDesc;
pBackBuffer->GetDesc(&backBufferSurfaceDesc);
ZeroMemory(&vp, sizeof(vp));
vp.Width = static_cast<float>(backBufferSurfaceDesc.Width);
vp.Height = static_cast<float>(backBufferSurfaceDesc.Height);
vp.MinDepth = 0;
vp.MaxDepth = 1;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
pDeviceContext->RSSetViewports(1, &vp);
hr = pDevice->CreateRenderTargetView(pBackBuffer, NULL, &pRTV);
if (FAILED(hr)) {
ods("D3D11: pDevice->CreateRenderTargetView failed!");
return false;
}
pDeviceContext->OMSetRenderTargets(1, &pRTV, NULL);
// Settings for an "over" operation.
// https://en.wikipedia.org/w/index.php?title=Alpha_compositing&oldid=580659153#Description
D3D11_BLEND_DESC blend;
ZeroMemory(&blend, sizeof(blend));
blend.RenderTarget[0].BlendEnable = TRUE;
blend.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blend.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blend.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blend.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blend.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
blend.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blend.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
pDevice->CreateBlendState(&blend, &pBlendState);
if (FAILED(hr)) {
ods("D3D11: pDevice->CreateBlendState failed!");
return false;
}
pDeviceContext->OMSetBlendState(pBlendState, NULL, 0xffffffff);
hr = pDevice->CreateVertexShader(g_vertex_shader, sizeof(g_vertex_shader), NULL, &pVertexShader);
if (FAILED(hr)) {
ods("D3D11: Failed to create vertex shader.");
return false;
}
hr = pDevice->CreatePixelShader(g_pixel_shader, sizeof(g_pixel_shader), NULL, &pPixelShader);
if (FAILED(hr)) {
ods("D3D11: Failed to create pixel shader.");
return false;
}
pTexture = NULL;
pSRView = NULL;
// Define the input layout
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 },
};
hr = pDevice->CreateInputLayout(layout, ARRAY_NUM_ELEMENTS(layout), g_vertex_shader, sizeof(g_vertex_shader), &pVertexLayout);
if (FAILED(hr)) {
ods("D3D11: pDevice->CreateInputLayout failure!");
return false;
}
pDeviceContext->IASetInputLayout(pVertexLayout);
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DYNAMIC;
bd.ByteWidth = VERTEXBUFFER_SIZE;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bd.MiscFlags = 0;
hr = pDevice->CreateBuffer(&bd, NULL, &pVertexBuffer);
if (FAILED(hr)) {
ods("D3D11: pDevice->CreateBuffer failure!");
return false;
}
DWORD indices[] = {
0,1,3,
1,2,3,
};
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_IMMUTABLE;
bd.ByteWidth = sizeof(DWORD) * 6;
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA InitData;
ZeroMemory(&InitData, sizeof(InitData));
InitData.pSysMem = indices;
hr = pDevice->CreateBuffer(&bd, &InitData, &pIndexBuffer);
if (FAILED(hr)) {
ods("D3D11: pDevice->CreateBuffer failure!");
return false;
}
// Set index buffer
pDeviceContext->IASetIndexBuffer(pIndexBuffer, DXGI_FORMAT_R32_UINT, 0);
// Set primitive topology
pDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
if (!bDeferredContext) {
pMyStateBlock->Capture();
pOrigStateBlock->Apply();
}
pBackBuffer->Release();
return true;
}
result_t app_init_swapchain(struct app_swapchain* sc, HWND hwnd, uint width, uint height,
uint refresh_rate, int fullscreen, int vsync)
{
ASSERT(g_app);
HRESULT dxhr;
IDXGISwapChain* swapchain;
ID3D11Texture2D* backbuffer;
ID3D11RenderTargetView* rtv;
ID3D11Texture2D* depthstencil = NULL;
ID3D11DepthStencilView* dsv = NULL;
struct app_win* app = g_app;
DXGI_SWAP_CHAIN_DESC d3d_desc;
memset(&d3d_desc, 0x00, sizeof(d3d_desc));
if (width == 0 || height == 0) {
RECT wrc;
::GetClientRect(hwnd, &wrc);
width = wrc.right - wrc.left;
height = wrc.bottom - wrc.top;
}
d3d_desc.BufferDesc.Width = width;
d3d_desc.BufferDesc.Height = height;
d3d_desc.BufferDesc.RefreshRate.Numerator = refresh_rate;
d3d_desc.BufferDesc.RefreshRate.Denominator = 1;
d3d_desc.BufferDesc.Format = DEFAULT_DISPLAY_FORMAT;
d3d_desc.SampleDesc.Count = 1;
d3d_desc.SampleDesc.Quality = 0;
d3d_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
d3d_desc.BufferCount = BACKBUFFER_COUNT;
d3d_desc.Windowed = fullscreen ? FALSE : TRUE;
d3d_desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
d3d_desc.Flags = fullscreen ? DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH : 0;
d3d_desc.OutputWindow = hwnd;
dxhr = app->dxgi_factory->CreateSwapChain(app->dev, &d3d_desc, &swapchain);
if (FAILED(dxhr)) {
err_print(__FILE__, __LINE__, "swapchain creation failed");
return NULL;
}
/* get BackBuffer and Create RenderTargetView from it */
if (FAILED(swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backbuffer))) {
swapchain->Release();
return RET_FAIL;
}
if (FAILED(app->dev->CreateRenderTargetView(backbuffer, NULL, &rtv))) {
backbuffer->Release();
swapchain->Release();
return RET_FAIL;
}
/* depth/stencil */
D3D11_TEXTURE2D_DESC ds_desc;
memset(&ds_desc, 0x00, sizeof(ds_desc));
ds_desc.ArraySize = 1;
ds_desc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
ds_desc.Format = DXGI_FORMAT_R24G8_TYPELESS;
ds_desc.MipLevels = 1;
ds_desc.SampleDesc.Count = 1;
ds_desc.Width = width;
ds_desc.Height = height;
if (FAILED(app->dev->CreateTexture2D(&ds_desc, NULL, &depthstencil))) {
backbuffer->Release();
swapchain->Release();
return RET_FAIL;
}
D3D11_DEPTH_STENCIL_VIEW_DESC ds_view;
memset(&ds_view, 0x00, sizeof(ds_view));
ds_view.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
ds_view.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
if (FAILED(app->dev->CreateDepthStencilView(depthstencil, &ds_view, &dsv))) {
depthstencil->Release();
backbuffer->Release();
swapchain->Release();
return RET_FAIL;
}
sc->sc = swapchain;
sc->backbuff = backbuffer;
sc->depthbuff = depthstencil;
sc->dsv = dsv;
sc->rtv = rtv;
sc->fullscreen = fullscreen;
return RET_OK;
}
void init( HWND hWnd )
{
HRESULT hr;
DXGI_SWAP_CHAIN_DESC scDesc;
memset( &scDesc, 0, sizeof scDesc );
scDesc.BufferDesc.Width = g_windowWidth;
scDesc.BufferDesc.Height = g_windowHeight;
scDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
scDesc.BufferDesc.RefreshRate.Denominator = 1;
scDesc.BufferDesc.RefreshRate.Numerator = 60;
scDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
scDesc.BufferCount = 1;
scDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
scDesc.SampleDesc.Count = 1;
scDesc.Windowed = TRUE;
scDesc.OutputWindow = hWnd;
D3D_FEATURE_LEVEL features[] = { D3D_FEATURE_LEVEL_11_0 };
UINT flags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#ifndef NDEBUG
flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
IDXGISwapChain* swapChain;
ID3D11Device* device;
ID3D11DeviceContext* context;
hr = D3D11CreateDeviceAndSwapChain(
nullptr, D3D_DRIVER_TYPE_HARDWARE, NULL, flags, features, ARRAYSIZE( features ),
D3D11_SDK_VERSION, &scDesc, &swapChain, &device, &featureLevel_, &context );
Assert( hr );
swapChain_.reset( swapChain );
device_.reset( device );
context_.reset( context );
ID3D11Texture2D* backBuffer;
ID3D11RenderTargetView* backBufferRTV;
hr = swapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), reinterpret_cast< void** >( &backBuffer ) );
Assert( hr );
hr = device_->CreateRenderTargetView( backBuffer, nullptr, &backBufferRTV );
Assert( hr );
backBufferRTV_.reset( backBufferRTV );
backBuffer->Release();
// Common state
ID3D11RasterizerState* rs;
D3D11_RASTERIZER_DESC rsDesc;
memset( &rsDesc, 0, sizeof rsDesc );
rsDesc.CullMode = D3D11_CULL_BACK;
rsDesc.FillMode = D3D11_FILL_SOLID;
rsDesc.DepthClipEnable = TRUE;
hr = device_->CreateRasterizerState( &rsDesc, &rs );
Assert( hr );
rasterState_.reset( rs );
// Body
std::string binData;
std::string vsBinData;
ID3D11VertexShader* vs;
binData = fileGetContents( "def.vs.cso" );
hr = device_->CreateVertexShader(
reinterpret_cast< const void* >( binData.c_str() ), binData.size(), nullptr, &vs );
Assert( hr );
modelVS_.reset( vs );
vsBinData = binData;
ID3D11PixelShader* ps;
binData = fileGetContents( "def.ps.cso" );
hr = device_->CreatePixelShader(
reinterpret_cast< const void* >( binData.c_str() ), binData.size(), nullptr, &ps );
Assert( hr );
modelPS_.reset( ps );
D3D11_BUFFER_DESC bufDesc = CD3D11_BUFFER_DESC( 64, D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DEFAULT, 0 );
ID3D11Buffer* buf;
hr = device_->CreateBuffer( &bufDesc, nullptr, &buf );
Assert( hr );
modelCB_.reset( buf );
// 四角錐ポリゴン
static const MeshFormat pyramidVertex[] = {
{ -1.0f, 0.0f, -1.0f, 0xFF33AAAA },
{ 1.0f, 0.0f, -1.0f, 0xFF33AAAA },
{ -1.0f, 0.0f, 1.0f, 0xFF33AAAA },
{ -1.0f, 0.0f, 1.0f, 0xFF33AAAA },
{ 1.0f, 0.0f, -1.0f, 0xFF33AAAA },
{ 1.0f, 0.0f, 1.0f, 0xFF33AAAA },
{ 1.0f, 0.0f, -1.0f, 0xFFEE33BB },
{ -1.0f, 0.0f, -1.0f, 0xFFEE33BB },
{ 0.0f, 1.0f, 0.0f, 0xFFEE33BB },
{ -1.0f, 0.0f, -1.0f, 0xFFCC33BB },
{ -1.0f, 0.0f, 1.0f, 0xFFCC33BB },
{ 0.0f, 1.0f, 0.0f, 0xFFCC33BB },
{ -1.0f, 0.0f, 1.0f, 0xFFAA33BB },
{ 1.0f, 0.0f, 1.0f, 0xFFAA33BB },
{ 0.0f, 1.0f, 0.0f, 0xFFAA33BB },
{ 1.0f, 0.0f, 1.0f, 0xFF8833BB },
{ 1.0f, 0.0f, -1.0f, 0xFF8833BB },
{ 0.0f, 1.0f, 0.0f, 0xFF8833BB },
};
bufDesc = CD3D11_BUFFER_DESC( sizeof pyramidVertex, D3D11_BIND_VERTEX_BUFFER, D3D11_USAGE_IMMUTABLE, 0 );
D3D11_SUBRESOURCE_DATA subresData;
subresData.pSysMem = pyramidVertex;
subresData.SysMemPitch = subresData.SysMemSlicePitch = 0;
hr = device_->CreateBuffer( &bufDesc, &subresData, &buf );
Assert( hr );
modelVB_.reset( buf );
D3D11_INPUT_ELEMENT_DESC ieDesc[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_B8G8R8A8_UNORM, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
ID3D11InputLayout* il;
hr = device_->CreateInputLayout( ieDesc, ARRAYSIZE( ieDesc ), vsBinData.data(), vsBinData.size(), &il );
Assert( hr );
modelIL_.reset( il );
}
void D10State::init() {
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10CreateEffectFromMemory);
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10CreateStateBlock);
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10StateBlockMaskEnableAll);
HRESULT hr;
dwMyThread = GetCurrentThreadId();
D3D10_STATE_BLOCK_MASK StateBlockMask;
ZeroMemory(&StateBlockMask, sizeof(StateBlockMask));
pD3D10StateBlockMaskEnableAll(&StateBlockMask);
pD3D10CreateStateBlock(pDevice, &StateBlockMask, &pOrigStateBlock);
pD3D10CreateStateBlock(pDevice, &StateBlockMask, &pMyStateBlock);
pOrigStateBlock->Capture();
ID3D10Texture2D* pBackBuffer = NULL;
hr = pSwapChain->GetBuffer(0, __uuidof(*pBackBuffer), (LPVOID*)&pBackBuffer);
pDevice->ClearState();
D3D10_TEXTURE2D_DESC backBufferSurfaceDesc;
pBackBuffer->GetDesc(&backBufferSurfaceDesc);
ZeroMemory(&vp, sizeof(vp));
vp.Width = backBufferSurfaceDesc.Width;
vp.Height = backBufferSurfaceDesc.Height;
vp.MinDepth = 0;
vp.MaxDepth = 1;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
pDevice->RSSetViewports(1, &vp);
hr = pDevice->CreateRenderTargetView(pBackBuffer, NULL, &pRTV);
pDevice->OMSetRenderTargets(1, &pRTV, NULL);
D3D10_BLEND_DESC blend;
ZeroMemory(&blend, sizeof(blend));
blend.BlendEnable[0] = TRUE;
blend.SrcBlend = D3D10_BLEND_ONE;
blend.DestBlend = D3D10_BLEND_INV_SRC_ALPHA;
blend.BlendOp = D3D10_BLEND_OP_ADD;
blend.SrcBlendAlpha = D3D10_BLEND_ONE;
blend.DestBlendAlpha = D3D10_BLEND_INV_SRC_ALPHA;
blend.BlendOpAlpha = D3D10_BLEND_OP_ADD;
blend.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL;
pDevice->CreateBlendState(&blend, &pBlendState);
float bf[4];
pDevice->OMSetBlendState(pBlendState, bf, 0xffffffff);
pD3D10CreateEffectFromMemory((void *) g_main, sizeof(g_main), 0, pDevice, NULL, &pEffect);
pTechnique = pEffect->GetTechniqueByName("Render");
pDiffuseTexture = pEffect->GetVariableByName("txDiffuse")->AsShaderResource();
pTexture = NULL;
pSRView = NULL;
// Define the input layout
D3D10_INPUT_ELEMENT_DESC layout[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = sizeof(layout) / sizeof(layout[0]);
// Create the input layout
D3D10_PASS_DESC PassDesc;
pTechnique->GetPassByIndex(0)->GetDesc(&PassDesc);
hr = pDevice->CreateInputLayout(layout, numElements, PassDesc.pIAInputSignature, PassDesc.IAInputSignatureSize, &pVertexLayout);
pDevice->IASetInputLayout(pVertexLayout);
D3D10_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D10_USAGE_DYNAMIC;
bd.ByteWidth = sizeof(SimpleVertex) * 4;
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
bd.MiscFlags = 0;
hr = pDevice->CreateBuffer(&bd, NULL, &pVertexBuffer);
DWORD indices[] = {
0,1,3,
1,2,3,
};
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = sizeof(DWORD) * 6;
bd.BindFlags = D3D10_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
D3D10_SUBRESOURCE_DATA InitData;
ZeroMemory(&InitData, sizeof(InitData));
InitData.pSysMem = indices;
hr = pDevice->CreateBuffer(&bd, &InitData, &pIndexBuffer);
// Set index buffer
pDevice->IASetIndexBuffer(pIndexBuffer, DXGI_FORMAT_R32_UINT, 0);
// Set primitive topology
pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
pMyStateBlock->Capture();
pOrigStateBlock->Apply();
pBackBuffer->Release();
dwMyThread = 0;
}
// WinMain
int APIENTRY _tWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow )
{
HRESULT hr;
// ウィンドウクラスを登録
WNDCLASSEX wcex = {
sizeof( WNDCLASSEX ), // cbSize
CS_HREDRAW | CS_VREDRAW, // style
WndProc, // lpfnWndProc
0, // cbClsExtra
0, // cbWndExtra
hInstance, // hInstance
NULL, // hIcon
NULL, // hCursor
( HBRUSH )( COLOR_WINDOW + 1 ), // hbrBackGround
NULL, // lpszMenuName
g_className, // lpszClassName
NULL // hIconSm
};
if ( ! RegisterClassEx( &wcex ) )
{
MessageBox( NULL, _T( "失敗: RegisterClassEx()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "RegisterClassEx: ok\n" ) );
// ウィンドウサイズを計算
RECT r = { 0, 0, 800, 450 }; // 800x450 (16:9)
if ( ! AdjustWindowRect( &r, WS_OVERLAPPEDWINDOW, FALSE ) )
{
MessageBox( NULL, _T( "失敗: AdjustWindowRect()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "AdjustWindowRect: ok (%d, %d)－(%d, %d)\n" ), r.left, r.top, r.right, r.bottom );
// ウィンドウ生成
HWND hWnd;
hWnd = CreateWindow( g_className,
g_windowName,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
0,
r.right - r.left,
r.bottom - r.top,
NULL,
NULL,
hInstance,
NULL );
if ( hWnd == NULL )
{
MessageBox( NULL, _T( "失敗: CreateWindow()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "CreateWindow: ok\n" ) );
// ウィンドウ表示
ShowWindow(hWnd, nCmdShow);
dtprintf( _T( "ShowWindow: ok\n" ) );
// スワップチェイン設定
DXGI_SWAP_CHAIN_DESC scDesc = {
{
1280, // BufferDesc.Width
720, // BufferDesc.Height
{
60, // BufferDesc.RefreshRate.Numerator
1 // BufferDesc.RefreshRate.Denominator
},
DXGI_FORMAT_R16G16B16A16_FLOAT, // BufferDesc.Format
DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED, // BufferDesc.ScanlineOrdering
DXGI_MODE_SCALING_CENTERED // BufferDesc.Scaling
},
{
1, // SampleDesc.Count
0 // SampleDesc.Quality
},
DXGI_USAGE_RENDER_TARGET_OUTPUT, // BufferUsage
1, // BufferCount
hWnd, // OutputWindow
TRUE, // Windowed
DXGI_SWAP_EFFECT_DISCARD, // SwapEffect
DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH // Flags
};
// Direct3D11 デバイス・デバイスコンテキスト・スワップチェーン生成
ID3D11Device * pDevice = NULL;
ID3D11DeviceContext * pDeviceContext = NULL;
IDXGISwapChain * pSwapChain = NULL;
D3D_FEATURE_LEVEL feature;
hr = D3D11CreateDeviceAndSwapChain( NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
0,
NULL,
0,
D3D11_SDK_VERSION,
&scDesc,
&pSwapChain,
&pDevice,
&feature,
&pDeviceContext );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: D3D11CreateDeviceAndSwapChain()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "D3D11CreateDeviceAndSwapChain: ok (pDevice: 0x%p, pDeviceContext: 0x%p, pSwapChain: 0x%p, feature: 0x%4x)\n" ),
pDevice,
pDeviceContext,
pSwapChain,
( int ) feature );
// バックバッファテクスチャ取得
ID3D11Texture2D * pBackBuffer = NULL;
hr = pSwapChain->GetBuffer( 0, __uuidof( pBackBuffer ), reinterpret_cast< void ** >( &pBackBuffer ) );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: IDXGISwapChain::GetBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "IDXGISwapChain::GetBuffer: ok (pBackBuffer: 0x%p)\n" ), pBackBuffer );
// レンダーターゲットビュー生成
ID3D11RenderTargetView * pRenderTargetView = NULL;
hr = pDevice->CreateRenderTargetView( pBackBuffer, NULL, &pRenderTargetView );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateRenderTargetView()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateRenderTargetView: ok (pRenderTargetView: 0x%p)\n" ), pRenderTargetView );
// レンダーターゲットビューをバインド
pDeviceContext->OMSetRenderTargets( 1, &pRenderTargetView, NULL );
dtprintf( _T( "ID3D11DeviceContext::OMSetRenderTargets: ok\n" ) );
// バックバッファはもうここでは使わない
COM_SAFE_RELEASE( pBackBuffer );
// ビューポートをバインド
D3D11_VIEWPORT viewport = {
0.0f, // TopLeftX
0.0f, // TopLeftY
1280.0f, // Width
720.0f, // Height
0.0f, // MinDepth
1.0f // MaxDepth
};
pDeviceContext->RSSetViewports( 1, &viewport );
dtprintf( _T( "ID3D11DeviceContext::RSSetViewports: ok\n" ) );
// 頂点データ
float vertices[ 5 ][ 7 ] = {
// Xaxis Yaxis Zaxis 赤 緑 青 Alpha
{ 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f }, // 原点
{ -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f }, // 左上
{ 0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 0.0f, 1.0f }, // 右上
{ 0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f }, // 右下
{ -0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f } // 左下
};
// 入力エレメント記述子
D3D11_INPUT_ELEMENT_DESC verticesDesc[] = {
{ "IN_POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "IN_COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, sizeof(float)*3, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
// 頂点バッファを生成
D3D11_BUFFER_DESC vertexBufferDesc = {
5 * sizeof( float ) * 7, // ByteWidth
D3D11_USAGE_DEFAULT, // Usage
D3D11_BIND_VERTEX_BUFFER, // BindFlags
0, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
D3D11_SUBRESOURCE_DATA vertexResourceData = { vertices };
ID3D11Buffer * pVertexBuffer = NULL;
hr = pDevice->CreateBuffer( &vertexBufferDesc, &vertexResourceData, &pVertexBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pVertexBuffer: 0x%p)\n" ), pVertexBuffer );
// 頂点バッファをバインド
UINT strides[] = { sizeof( float ) * 7 };
UINT offsets[] = { 0 };
pDeviceContext->IASetVertexBuffers( 0, 1, &pVertexBuffer, strides, offsets );
dtprintf( _T( "ID3D11DeviceContext::IASetVertexBuffers: ok\n" ) );
// インデックスデータ
unsigned int indices[] = { 0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 1 };
// インデックスバッファを生成
D3D11_BUFFER_DESC indexBufferDesc = {
sizeof( unsigned int ) * 12, // ByteWidth
D3D11_USAGE_DEFAULT, // Usage
D3D11_BIND_INDEX_BUFFER, // BindFlags
0, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
D3D11_SUBRESOURCE_DATA indexResourceData = { indices };
ID3D11Buffer * pIndexBuffer = NULL;
hr = pDevice->CreateBuffer( &indexBufferDesc, &indexResourceData, &pIndexBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pIndexBuffer: 0x%p)\n" ), pIndexBuffer );
// インデックスバッファをバインド
pDeviceContext->IASetIndexBuffer( pIndexBuffer, DXGI_FORMAT_R32_UINT, 0 );
dtprintf( _T( "ID3D11DeviceContext::IASetIndexBuffer: ok\n" ) );
// プリミティブタイプを設定
pDeviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
dtprintf( _T( "ID3D11DeviceContext::IASetPrimitiveTopology: ok\n" ) );
// 頂点シェーダを作成
ID3D11VertexShader * pVertexShader = NULL;
hr = pDevice->CreateVertexShader( g_vs_constant, sizeof( g_vs_constant ), NULL, &pVertexShader );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateVertexShader()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateVertexShader: ok (pVertexShader: 0x%p)\n" ), pVertexShader );
// ピクセルシェーダを作成
ID3D11PixelShader * pPixelShader = NULL;
hr = pDevice->CreatePixelShader( g_ps_constant, sizeof( g_ps_constant ), NULL, &pPixelShader );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreatePixelShader()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreatePixelShader: ok (pPixelShader: 0x%p)\n" ), pPixelShader );
// シェーダをバインド
pDeviceContext->VSSetShader( pVertexShader, NULL, 0 );
dtprintf( _T( "ID3D11DeviceContext::VSSetShader: ok\n" ) );
pDeviceContext->PSSetShader( pPixelShader, NULL, 0 );
dtprintf( _T( "ID3D11DeviceContext::PSSetShader: ok\n" ) );
pDeviceContext->GSSetShader( NULL, NULL, 0 );
pDeviceContext->HSSetShader( NULL, NULL, 0 );
pDeviceContext->DSSetShader( NULL, NULL, 0 );
// 入力レイアウトを生成
ID3D11InputLayout * pInputLayout = NULL;
hr = pDevice->CreateInputLayout( verticesDesc, 2, g_vs_constant, sizeof( g_vs_constant ), &pInputLayout );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateInputLayout()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateInputLayout: ok (pInputLayout: 0x%p)\n" ), pInputLayout );
// 入力レイアウトをバインド
pDeviceContext->IASetInputLayout( pInputLayout );
dtprintf( _T( "ID3D11DeviceContext::IASetInputLayout: ok\n" ) );
MSG msg;
while ( 1 )
{
// メッセージを取得
if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
if ( msg.message == WM_QUIT )
{
dtprintf( _T( "PeekMessage: WM_QUIT\n" ) );
break;
}
// メッセージ処理
DispatchMessage( &msg );
}
else
{
// レンダーターゲットをクリア
const float clear[ 4 ] = { 0.0f, 0.0f, 1.0f, 1.0f }; // RGBA
pDeviceContext->ClearRenderTargetView( pRenderTargetView, clear );
// 描画
pDeviceContext->DrawIndexed( 12, 0, 0 );
pSwapChain->Present( 1, 0 );
// ちょっとだけ待つ
Sleep( 5 );
}
}
// シェーダをアンバインド
pDeviceContext->VSSetShader( NULL, NULL, 0 );
pDeviceContext->PSSetShader( NULL, NULL, 0 );
// デバイス・リソース解放
COM_SAFE_RELEASE( pInputLayout );
COM_SAFE_RELEASE( pPixelShader );
COM_SAFE_RELEASE( pVertexShader );
COM_SAFE_RELEASE( pIndexBuffer );
COM_SAFE_RELEASE( pVertexBuffer );
COM_SAFE_RELEASE( pRenderTargetView );
COM_SAFE_RELEASE( pSwapChain );
COM_SAFE_RELEASE( pDeviceContext );
COM_SAFE_RELEASE( pDevice );
return msg.wParam;
}
std::unique_ptr<SwapChain> SwapChain_<>::Create( const Config &config ) {
SwapChain* retval = nullptr;
#if defined(LUDI_PLATFORM_XENON)
retval = nullptr;
#elif defined(LUDI_PLATFORM_PS3)
retval = nullptr;
#elif defined(LUDI_PLATFORM_WII)
retval = nullptr;
#elif LUDI_PLATFORM_ID == LUDI_PLATFORM_WINDOWS
// Attempt to get the DXGI Factory.
Device* device = Device::Get();
Driver* driver = device->driver();
// Attempt to create the swap chain.
IDXGISwapChain* chain = nullptr;
// Create the swap chain
DXGI_SWAP_CHAIN_DESC desc;
desc = ConversionDx11::To(config);
HRESULT hresult = driver->factory()->CreateSwapChain(device->device(), &desc, &chain);
if (FAILED(hresult)) {
//Log::Get().Write( L"Failed to create swap chain!" );
ASSERT(false);
return nullptr;
}
// Retrieve the texture buffer (render-texture)
ID3D11Texture2D* texture = nullptr;
hresult = chain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), reinterpret_cast< void** >( &texture ) );
if (FAILED(hresult)) {
//Log::Get().Write( L"Failed to get swap chain texture resource!" );
ASSERT(false);
return nullptr;
}
// Create the swap chain render target view
ID3D11RenderTargetView* view;
hresult = (*device)->CreateRenderTargetView(texture, nullptr, &view);
if (FAILED(hresult)) {
//Log::Get().Write( L"Failed to create render target view for swap chain!" );
ASSERT(false);
return nullptr;
}
// Create the swap chain, set the render texture and render target view
retval = new SwapChain_<LUDI_PLATFORM_WINDOWS>(chain);
retval->set_render_texture(new Texture(texture));
retval->set_render_target_view(new RenderTargetView(view));
#elif LUDI_PLATFORM_ID == LUDI_PLATFORM_OSX
retval = new SwapChain_<LUDI_PLATFORM_OSX>(nullptr);
retval->set_render_texture(new Texture());
retval->set_render_target_view(new RenderTargetView());
#else // NO VALID PLATFORM
retval = nullptr;
#endif
return std::unique_ptr<SwapChain>(retval);
}