Mesh::~Mesh()
{
// Release any D3D stuff that's still hanging out
ReleaseMacro(vBuffer);
ReleaseMacro(iBuffer);
}
Game::~Game()
{
destructFunc();
delete shadowVS;
ResourceManager::manager->shutdown();
freeAllGameObjects();
ReleaseMacro(renderTargetView);
ReleaseMacro(depthStencilView);
ReleaseMacro(swapChain);
ReleaseMacro(depthStencilBuffer);
ReleaseMacro(shadowSampler);
ReleaseMacro(shadowMapDSV);
ReleaseMacro(shadowMapSRV);
ReleaseMacro(shadowRS);
if (deviceContext)
deviceContext->ClearState();
ReleaseMacro(deviceContext);
ReleaseMacro(device);
game = nullptr;
}
FXAA::~FXAA(){
ReleaseMacro(aaRTV);
ReleaseMacro(aaSRV);
delete edges;
delete fxaaPS;
}
Pulse::~Pulse()
{
ReleaseMacro(pulseRTV);
ReleaseMacro(pulseSRV);
ReleaseMacro(pulseTexture);
delete pulsePS;
}
Mesh::~Mesh()
{
if (vertexBuffer != nullptr)
{
ReleaseMacro(vertexBuffer);
vertexBuffer = nullptr;
}
if (indexBuffer != nullptr)
{
ReleaseMacro(indexBuffer);
indexBuffer = nullptr;
}
if (vertices != nullptr)
{
delete[] vertices;
vertices = nullptr;
}
if (indices != nullptr)
{
delete[] indices;
indices = nullptr;
}
}
// Destroys this font
Font::~Font()
{
Dispose();
ReleaseMacro( _deviceContext );
ReleaseMacro( _device );
}
Trace::~Trace() {
mLineTraceMesh->~IMesh();
ReleaseMacro(mLineTraceInputLayout);
ReleaseMacro(mVSLineTrace);
ReleaseMacro(mPSSimpleColor);
ReleaseMacro(mLineTraceShaderBuffer);
}
void dx_info::resize(int32_t width, int32_t height)
{
// Release any existing views, since we'll be destroying
// the corresponding buffers.
ReleaseMacro(this->render_target_view);
ReleaseMacro(this->depth_stencil_view);
ReleaseMacro(this->depth_stencil_buffer);
// Resize the swap chain to match the new window dimensions
HR(this->swap_chain->ResizeBuffers(
1,
width,
height,
DXGI_FORMAT_R8G8B8A8_UNORM,
0));
// Recreate the render target view that points to the swap chain's buffer
ID3D11Texture2D* backBuffer;
HR(this->swap_chain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&backBuffer)));
HR(this->device->CreateRenderTargetView(backBuffer, 0, &this->render_target_view));
ReleaseMacro(backBuffer);
// Set up the description of the texture to use for the depth buffer
D3D11_TEXTURE2D_DESC depthStencilDesc;
depthStencilDesc.Width = width;
depthStencilDesc.Height = height;
depthStencilDesc.MipLevels = 1;
depthStencilDesc.ArraySize = 1;
depthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilDesc.Usage = D3D11_USAGE_DEFAULT;
depthStencilDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthStencilDesc.CPUAccessFlags = 0;
depthStencilDesc.MiscFlags = 0;
depthStencilDesc.SampleDesc.Count = 1;
depthStencilDesc.SampleDesc.Quality = 0;
// Create the depth/stencil buffer and corresponding view
HR(this->device->CreateTexture2D(&depthStencilDesc, 0, &this->depth_stencil_buffer));
HR(this->device->CreateDepthStencilView(this->depth_stencil_buffer, 0, &this->depth_stencil_view));
// Bind these views to the pipeline, so rendering properly
// uses the underlying textures
this->device_context->OMSetRenderTargets(1, &this->render_target_view, this->depth_stencil_view);
// Update the viewport to match the new window size and set it on the device
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = (float)width;
viewport.Height = (float)height;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
this->device_context->RSSetViewports(1, &viewport);
// Recalculate the aspect ratio, since it probably changed
this->aspect_ratio = (float)width / height;
}
MyDemoGame::~MyDemoGame()
{
deleteHelper<Game>(m_game);
//renderTarget.Shutdown();
//deleteHelper<GameEntity>(ship);
ReleaseMacro(deviceContext);
ReleaseMacro(device);
ReleaseMacro(depthStencilBuffer);
ReleaseMacro(depthStencilView);
}
EdgeOutlineDetect::~EdgeOutlineDetect()
{
ReleaseMacro( edgeRTV );
ReleaseMacro( edgeSRV );
ReleaseMacro( blurRTV );
ReleaseMacro( blurSRV );
delete edgePS;
delete blurPS;
}
Simulation::~Simulation()
{
for (GameObject* obj : objects)
{
delete obj;
obj = 0;
}
ReleaseMacro(inputLayout);
ReleaseMacro(matrixBuffer);
ReleaseMacro(blendState);
ReleaseMacro(solid);
ReleaseMacro(wireframe)
}
Collectable::~Collectable(){
ReleaseMacro(device);
ReleaseMacro(deviceContext);
if (sampler){
delete sampler;
sampler = nullptr;
}
if (collectableMaterial){
delete collectableMaterial;
collectableMaterial = nullptr;
}
if (shaderProgram){
delete shaderProgram;
shaderProgram = nullptr;
}
}
void Game::OnResize()
{
ReleaseMacro(renderTargetView);
ReleaseMacro(depthStencilView);
ReleaseMacro(depthStencilBuffer);
swapChain->ResizeBuffers(
1,
windowWidth,
windowHeight,
DXGI_FORMAT_R8G8B8A8_UNORM,
NULL);
ID3D11Texture2D* backBuffer;
swapChain->GetBuffer(NULL, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&backBuffer));
dev->CreateRenderTargetView(backBuffer, 0, &renderTargetView);
ReleaseMacro(backBuffer);
D3D11_TEXTURE2D_DESC dsd;
ZeroMemory(&dsd, sizeof(D3D11_TEXTURE2D_DESC));
dsd.Width = windowWidth;
dsd.Height = windowHeight;
dsd.MipLevels = 1;
dsd.ArraySize = 1;
dsd.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
dsd.Usage = D3D11_USAGE_DEFAULT;
dsd.BindFlags = D3D11_BIND_DEPTH_STENCIL;
dsd.CPUAccessFlags = NULL;
dsd.MiscFlags = NULL;
dsd.SampleDesc.Count = 4;
dev->CreateTexture2D(&dsd, NULL, &depthStencilBuffer);
dev->CreateDepthStencilView(depthStencilBuffer, NULL, &depthStencilView);
devCon->OMSetRenderTargets(1, &renderTargetView, depthStencilView);
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = (float)windowWidth;
viewport.Height = (float)windowHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
devCon->RSSetViewports(1, &viewport);
}
// Clean up states
void DeviceManager::Cleanup(ID3D11Device* device){
ReleaseMacro(_dsEnableStencil);
ReleaseMacro(_dsDisableStencil);
ReleaseMacro(_dsLessEqual);
ReleaseMacro(_rsCullBack);
ReleaseMacro(_rsCullNone);
ReleaseMacro(_rsWireframe);
ReleaseMacro(_rsWireframeCullBack);
};
Game::~Game(void)
{
ReleaseMacro(depthStencilView);
ReleaseMacro(depthStencilBuffer);
ReleaseMacro(renderTargetView);
ReleaseMacro(swapChain);
if (devCon)
devCon->ClearState();
ReleaseMacro(devCon);
ReleaseMacro(dev);
}
// --------------------------------------------------------
// Destructor - Clean up (release) all DirectX references
// --------------------------------------------------------
DirectXGameCore::~DirectXGameCore(void)
{
// Release the core DirectX "stuff" we set up
ReleaseMacro(renderTargetView);
ReleaseMacro(depthStencilView);
ReleaseMacro(swapChain);
ReleaseMacro(depthStencilBuffer);
// Restore default device settings
if( deviceContext )
deviceContext->ClearState();
// Release the device context and finally the device itself
ReleaseMacro(deviceContext);
ReleaseMacro(device);
}
void DX::Release()
{
// Release the DX stuff
ReleaseMacro(renderTargetView);
ReleaseMacro(depthStencilView);
ReleaseMacro(swapChain);
ReleaseMacro(depthStencilBuffer);
// Restore default device settings
if (deviceContext)
deviceContext->ClearState();
// Release the context and finally the device
ReleaseMacro(deviceContext);
ReleaseMacro(device);
CameraManager::Release();
GameStateManager::Release();
}
DirectXGame::~DirectXGame(void)
{
// Release the DX stuff
ReleaseMacro(backBufferRenderTargetView[0]);
//ReleaseMacro(pPRenderTargetView[0]);
//ReleaseMacro(pPRenderTargetView[1]);
//ReleaseMacro(pPRenderTargetView[2]);
ReleaseMacro(depthStencilView);
ReleaseMacro(swapChain);
ReleaseMacro(depthStencilBuffer);
// Restore default device settings
if (deviceContext)
deviceContext->ClearState();
// Release the context and finally the device
ReleaseMacro(deviceContext);
ReleaseMacro(device);
}
void Level00::VShutdown()
{
mCircleMesh->~IMesh();
mWallMesh->~IMesh();
ReleaseMacro(mQuadInputLayout);
ReleaseMacro(mQuadVertexShader);
ReleaseMacro(mQuadPixelShader);
ReleaseMacro(mQuadShaderBuffer);
ReleaseMacro(mWallInstanceBuffer);
ReleaseMacro(mCircleInputLayout);
ReleaseMacro(mCircleVertexShader);
ReleaseMacro(mCirclePixelShader);
ReleaseMacro(mCircleInstanceBuffer);
ReleaseMacro(mColorWeightInstanceBuffer);
ReleaseMacro(mPlayerInstanceBuffer);
ReleaseMacro(mShadowCastersRTV);
ReleaseMacro(mShadowCastersMap);
ReleaseMacro(mShadowCastersSRV);
ReleaseMacro(mShadowsARTV);
ReleaseMacro(mShadowsAMap);
ReleaseMacro(mShadowsASRV);
ReleaseMacro(mShadowsBRTV);
ReleaseMacro(mShadowsBMap);
ReleaseMacro(mShadowsBSRV);
ReleaseMacro(mShadowsFinalRTV);
ReleaseMacro(mShadowsFinalMap);
ReleaseMacro(mShadowsFinalSRV);
ReleaseMacro(mBillboardVertexShader);
ReleaseMacro(mBillboardPixelShader);
ReleaseMacro(mShadowCasterPixelShader);
ReleaseMacro(mShadowPixelShader);
ReleaseMacro(mBlendStateShadowMask);
ReleaseMacro(mBlendStateShadowCalc);
ReleaseMacro(mSamplerState);
ReleaseMacro(mPointShaderBuffer);
ReleaseMacro(mShadowGridComputeShader);
ReleaseMacro(mSrcDataGPUBuffer);
ReleaseMacro(mSrcDataGPUBufferView);
ReleaseMacro(mDestDataGPUBuffer);
ReleaseMacro(mDestDataGPUBufferCPURead);
ReleaseMacro(mDestDataGPUBufferView);
}
void Level00::VOnResize()
{
ReleaseMacro(mShadowCastersRTV);
ReleaseMacro(mShadowCastersMap);
ReleaseMacro(mShadowCastersSRV);
ReleaseMacro(mShadowsARTV);
ReleaseMacro(mShadowsAMap);
ReleaseMacro(mShadowsASRV);
ReleaseMacro(mShadowsBRTV);
ReleaseMacro(mShadowsBMap);
ReleaseMacro(mShadowsBSRV);
ReleaseMacro(mShadowsFinalRTV);
ReleaseMacro(mShadowsFinalMap);
ReleaseMacro(mShadowsFinalSRV);
ReleaseMacro(mDestDataGPUBuffer);
ReleaseMacro(mDestDataGPUBufferCPURead);
ReleaseMacro(mDestDataGPUBufferView);
ReleaseMacro(mSrcDataGPUBufferView);
D3D11_TEXTURE2D_DESC shadowCastersTextureDesc;
shadowCastersTextureDesc.Width = mRenderer->GetWindowWidth();
shadowCastersTextureDesc.Height = mRenderer->GetWindowHeight();
shadowCastersTextureDesc.ArraySize = 1;
shadowCastersTextureDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
shadowCastersTextureDesc.CPUAccessFlags = 0;
shadowCastersTextureDesc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
shadowCastersTextureDesc.MipLevels = 1;
shadowCastersTextureDesc.MiscFlags = 0;
shadowCastersTextureDesc.SampleDesc.Count = 1;
shadowCastersTextureDesc.SampleDesc.Quality = 0;
shadowCastersTextureDesc.Usage = D3D11_USAGE_DEFAULT;
mDevice->CreateTexture2D(&shadowCastersTextureDesc, nullptr, &mShadowCastersMap);
mDevice->CreateTexture2D(&shadowCastersTextureDesc, nullptr, &mShadowsAMap);
mDevice->CreateTexture2D(&shadowCastersTextureDesc, nullptr, &mShadowsBMap);
mDevice->CreateTexture2D(&shadowCastersTextureDesc, nullptr, &mShadowsFinalMap);
D3D11_RENDER_TARGET_VIEW_DESC shadowCastersRTVDesc;
shadowCastersRTVDesc.Format = shadowCastersTextureDesc.Format;
shadowCastersRTVDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
shadowCastersRTVDesc.Texture2D.MipSlice = 0;
mRenderer->GetDevice()->CreateRenderTargetView(mShadowCastersMap, &shadowCastersRTVDesc, &mShadowCastersRTV);
mRenderer->GetDevice()->CreateRenderTargetView(mShadowsAMap, &shadowCastersRTVDesc, &mShadowsARTV);
mRenderer->GetDevice()->CreateRenderTargetView(mShadowsBMap, &shadowCastersRTVDesc, &mShadowsBRTV);
mRenderer->GetDevice()->CreateRenderTargetView(mShadowsFinalMap, &shadowCastersRTVDesc, &mShadowsFinalRTV);
D3D11_SHADER_RESOURCE_VIEW_DESC shadowCastersSRVDesc;
shadowCastersSRVDesc.Format = shadowCastersTextureDesc.Format;
shadowCastersSRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
shadowCastersSRVDesc.Texture2D.MipLevels = 1;
shadowCastersSRVDesc.Texture2D.MostDetailedMip = 0;
mDevice->CreateShaderResourceView(mShadowCastersMap, &shadowCastersSRVDesc, &mShadowCastersSRV);
mDevice->CreateShaderResourceView(mShadowsAMap, &shadowCastersSRVDesc, &mShadowsASRV);
mDevice->CreateShaderResourceView(mShadowsBMap, &shadowCastersSRVDesc, &mShadowsBSRV);
mDevice->CreateShaderResourceView(mShadowsFinalMap, &shadowCastersSRVDesc, &mShadowsFinalSRV);
{
D3D11_BUFFER_DESC descGPUBuffer;
ZeroMemory(&descGPUBuffer, sizeof(descGPUBuffer));
descGPUBuffer.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
descGPUBuffer.ByteWidth = numSpheresX*numSpheresY * sizeof(GridNode);
descGPUBuffer.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
descGPUBuffer.StructureByteStride = sizeof(GridNode);
mDevice->CreateBuffer(&descGPUBuffer, NULL, &mDestDataGPUBuffer);
descGPUBuffer.Usage = D3D11_USAGE_STAGING;
descGPUBuffer.BindFlags = 0;
descGPUBuffer.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
mDevice->CreateBuffer(&descGPUBuffer, NULL, &mDestDataGPUBufferCPURead);
D3D11_UNORDERED_ACCESS_VIEW_DESC descView;
ZeroMemory(&descView, sizeof(descView));
descView.Format = DXGI_FORMAT_UNKNOWN;
descView.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
descView.Buffer.NumElements = numSpheresX*numSpheresY;
mDevice->CreateUnorderedAccessView(mDestDataGPUBuffer, &descView, &mDestDataGPUBufferView);
}
{
D3D11_BUFFER_DESC descGPUBuffer;
ZeroMemory(&descGPUBuffer, sizeof(descGPUBuffer));
descGPUBuffer.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
descGPUBuffer.ByteWidth = numSpheresX*numSpheresY * sizeof(GridNode);
descGPUBuffer.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
descGPUBuffer.StructureByteStride = sizeof(GridNode);
D3D11_SUBRESOURCE_DATA InitData;
InitData.pSysMem = mGridNodeData;
mDevice->CreateBuffer(&descGPUBuffer, &InitData, &mSrcDataGPUBuffer);
D3D11_SHADER_RESOURCE_VIEW_DESC descView;
ZeroMemory(&descView, sizeof(descView));
descView.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX;
descView.BufferEx.FirstElement = 0;
descView.Format = DXGI_FORMAT_UNKNOWN;
descView.BufferEx.NumElements = numSpheresX*numSpheresY;
mDevice->CreateShaderResourceView(mSrcDataGPUBuffer, &descView, &mSrcDataGPUBufferView);
}
}
void Simulation::InitializePipeline()
{
D3D11_INPUT_ELEMENT_DESC vDesc[] =
{
{ "POSITION", NULL, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, NULL },
{ "COLOR", NULL, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, NULL },
{ "TEXCOORD", NULL, DXGI_FORMAT_R32G32_FLOAT, 0, 28, D3D11_INPUT_PER_VERTEX_DATA, NULL },
{ "NORMAL", NULL, DXGI_FORMAT_R32G32B32_FLOAT, 0, 36, D3D11_INPUT_PER_VERTEX_DATA, NULL },
{ "TANGENT", NULL, DXGI_FORMAT_R32G32B32_FLOAT, 0, 44, D3D11_INPUT_PER_VERTEX_DATA, NULL }
};
ID3DBlob* vertexByte;
D3DReadFileToBlob(L"Default.cso", &vertexByte);
dev->CreateInputLayout(vDesc, ARRAYSIZE(vDesc), vertexByte->GetBufferPointer(), vertexByte->GetBufferSize(), &inputLayout);
ReleaseMacro(vertexByte);
D3D11_BUFFER_DESC cd;
ZeroMemory(&cd, sizeof(D3D11_BUFFER_DESC));
cd.ByteWidth = sizeof(matrixBufferData);
cd.Usage = D3D11_USAGE_DEFAULT;
cd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cd.CPUAccessFlags = 0;
cd.MiscFlags = 0;
cd.StructureByteStride = 0;
dev->CreateBuffer(&cd, NULL, &matrixBuffer);
D3D11_BLEND_DESC bd;
ZeroMemory(&bd, sizeof(D3D11_BLEND_DESC));
bd.AlphaToCoverageEnable = false;
bd.IndependentBlendEnable = false;
bd.RenderTarget[0].BlendEnable = true;
bd.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
bd.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
bd.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
bd.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
bd.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
bd.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
bd.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
dev->CreateBlendState(&bd, &blendState);
D3D11_RASTERIZER_DESC rd;
ZeroMemory(&rd, sizeof(D3D11_RASTERIZER_DESC));
rd.FillMode = D3D11_FILL_WIREFRAME;
rd.CullMode = D3D11_CULL_BACK;
rd.FrontCounterClockwise = false;
rd.DepthBias = 0;
rd.DepthBiasClamp = 0;
rd.SlopeScaledDepthBias = 0;
rd.DepthClipEnable = true;
rd.ScissorEnable = false;
rd.MultisampleEnable = false;
rd.AntialiasedLineEnable = false;
dev->CreateRasterizerState(&rd, &wireframe);
rd.FillMode = D3D11_FILL_SOLID;
dev->CreateRasterizerState(&rd, &solid);
D3D11_DEPTH_STENCIL_DESC dsd;
ZeroMemory(&dsd, sizeof(D3D11_DEPTH_STENCIL_DESC));
dsd.DepthEnable = true;
dsd.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
dsd.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
dsd.StencilEnable = false;
dsd.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
dsd.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
dsd.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
dsd.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
dsd.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
dsd.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
dsd.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
dsd.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
dsd.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
dsd.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
dev->CreateDepthStencilState(&dsd, &depthStencilState);
}
Terrain::~Terrain()
{
ReleaseMacro(heightmap);
ReleaseMacro(normalmap);
ReleaseMacro(terrainBuffer);
}
bool DX::InitDirect3D()
{
UINT createDeviceFlags = 0;
// Do we want a debug device?
#if defined(DEBUG) || defined(_DEBUG)
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
// Create the device and determine the supported feature level
featureLevel = D3D_FEATURE_LEVEL_9_1; // Will be overwritten by next line
HRESULT hr = D3D11CreateDevice(
0,
driverType,
0,
createDeviceFlags,
0,
0,
D3D11_SDK_VERSION,
&device,
&featureLevel,
&deviceContext);
// Handle any device creation or DirectX version errors
if( FAILED(hr) )
{
MessageBox(0, L"D3D11CreateDevice Failed", 0, 0);
return false;
}
// Check for 4X MSAA quality support
HR(device->CheckMultisampleQualityLevels(
DXGI_FORMAT_R8G8B8A8_UNORM,
4,
&msaa4xQuality));
assert( msaa4xQuality > 0 ); // Potential problem if quality is 0
// Set up a swap chain description
DXGI_SWAP_CHAIN_DESC swapChainDesc;
swapChainDesc.BufferDesc.Width = windowWidth;
swapChainDesc.BufferDesc.Height = windowHeight;
swapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount = 1;
swapChainDesc.OutputWindow = hMainWnd;
swapChainDesc.Windowed = true;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags = 0;
if( enable4xMsaa )
{
// Set up 4x MSAA
swapChainDesc.SampleDesc.Count = 4;
swapChainDesc.SampleDesc.Quality = msaa4xQuality - 1;
}
else
{
// No MSAA
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
}
// To correctly create the swap chain, we must use the IDXGIFactory that
// was used to create the device.
IDXGIDevice* dxgiDevice = 0;
IDXGIAdapter* dxgiAdapter = 0;
IDXGIFactory* dxgiFactory = 0;
HR(device->QueryInterface( __uuidof(IDXGIDevice), (void**)&dxgiDevice));
HR(dxgiDevice->GetParent( __uuidof(IDXGIAdapter), (void**)&dxgiAdapter));
HR(dxgiAdapter->GetParent( __uuidof(IDXGIFactory), (void**)&dxgiFactory));
// Finally make the swap chain and release the DXGI stuff
HR(dxgiFactory->CreateSwapChain(device, &swapChainDesc, &swapChain));
ReleaseMacro(dxgiDevice);
ReleaseMacro(dxgiAdapter);
ReleaseMacro(dxgiFactory);
// The remaining steps also need to happen each time the window
// is resized, so just run the OnResize method
OnResize();
return true;
}
// When the window is resized, the underlying buffers (textures) must
// also be resized to match.
void DirectXGame::OnResize()
{
// Release the views, since we'll be destroying
// the corresponding buffers.
ReleaseMacro(backBufferRenderTargetView[0]);
//ReleaseMacro(pPRenderTargetView[0]);
//ReleaseMacro(pPRenderTargetView[1]);
//ReleaseMacro(pPRenderTargetView[2]);
ReleaseMacro(depthStencilView);
ReleaseMacro(depthStencilBuffer);
// Resize the swap chain to match the window and
// recreate the render target view
HR(swapChain->ResizeBuffers(1, windowWidth, windowHeight, DXGI_FORMAT_R8G8B8A8_UNORM, 0));
ID3D11Texture2D* renderBuffer;
HR(swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&renderBuffer)));
HR(device->CreateRenderTargetView(renderBuffer, 0, backBufferRenderTargetView));
ReleaseMacro(renderBuffer);
// Set up the description of the texture to use for the
// depth stencil buffer
D3D11_TEXTURE2D_DESC depthStencilDesc;
depthStencilDesc.Width = windowWidth;
depthStencilDesc.Height = windowHeight;
depthStencilDesc.MipLevels = 1;
depthStencilDesc.ArraySize = 1;
depthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilDesc.Usage = D3D11_USAGE_DEFAULT;
depthStencilDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthStencilDesc.CPUAccessFlags = 0;
depthStencilDesc.MiscFlags = 0;
if (enable4xMsaa)
{
// Turn on 4x MultiSample Anti Aliasing
// This must match swap chain MSAA values
depthStencilDesc.SampleDesc.Count = 4;
depthStencilDesc.SampleDesc.Quality = msaa4xQuality - 1;
}
else
{
// No MSAA
depthStencilDesc.SampleDesc.Count = 1;
depthStencilDesc.SampleDesc.Quality = 0;
}
// Create the depth/stencil buffer and corresponding view
HR(device->CreateTexture2D(&depthStencilDesc, 0, &depthStencilBuffer));
HR(device->CreateDepthStencilView(depthStencilBuffer, 0, &depthStencilView));
// Bind these views to the pipeline, so rendering actually
// uses the underlying textures
//deviceContext->OMSetRenderTargets(1, renderTargetView, depthStencilView);
// Update the viewport and set it on the device
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = (float)windowWidth;
viewport.Height = (float)windowHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
deviceContext->RSSetViewports(1, &viewport);
}
Drawable::~Drawable() { ReleaseMacro( vertexBuffer ); ReleaseMacro( indexBuffer ); }
ParticleGenerator::~ParticleGenerator() {
ReleaseMacro(particleBuff);
ReleaseMacro(readBuff);
ReleaseMacro(writeBuff);
}
Mesh::~Mesh()
{
ReleaseMacro(vertexBuffer);
ReleaseMacro(indexBuffer);
}
