HRESULT ParticleSystem::CreateRndTex(int size)
{
HRESULT hr = S_OK;
D3DXVECTOR4* randomValues = new D3DXVECTOR4[size];
for(int i = 0; i < size; i++)
{
randomValues[i].x = RndFloat(-1.0f, 1.0f);
randomValues[i].y = RndFloat(-1.0f, 1.0f);
randomValues[i].z = RndFloat(-1.0f, 1.0f);
randomValues[i].w = RndFloat(-1.0f, 1.0f);
}
D3D11_SUBRESOURCE_DATA subresData;
subresData.pSysMem = randomValues;
subresData.SysMemPitch = sizeof(D3DXVECTOR4) * size;
subresData.SysMemSlicePitch = sizeof(D3DXVECTOR4) * size;
D3D11_TEXTURE1D_DESC texDesc;
texDesc.Width = size;
texDesc.MipLevels = 1;
texDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
texDesc.Usage = D3D11_USAGE_IMMUTABLE;
texDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
texDesc.CPUAccessFlags = 0;
texDesc.MiscFlags = 0;
texDesc.ArraySize = 1;
ID3D11Texture1D* rndTex = NULL;
hr = this->gDevice->CreateTexture1D(&texDesc, &subresData, &rndTex);
if(FAILED(hr))
{
MessageBox(0, "Failed to create random texture", "CreateTexture1D", MB_ICONERROR);
}
D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc;
viewDesc.Format = texDesc.Format;
viewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D;
viewDesc.Texture1D.MipLevels = texDesc.MipLevels;
viewDesc.Texture1D.MostDetailedMip = 0;
hr = this->gDevice->CreateShaderResourceView(rndTex, &viewDesc, &this->mRndTexSRV);
if(FAILED(hr))
{
MessageBox(0, "Failed to create shader resource view", "CreateShaderResourceView", MB_ICONERROR);
}
rndTex->Release();
delete [] randomValues;
return hr;
}
void SSao::randomTex(ID3D11Device* dev, ID3D11DeviceContext *devCon)
{
XMFLOAT4 randValues[wind];
std::default_random_engine gen;
std::uniform_real_distribution<float> random(-1.0f, 1.0f);
for (int i = 0; i < wind; i++)
{
randValues[i].x = random(gen);
randValues[i].y = random(gen);
randValues[i].z = random(gen);
randValues[i].w = random(gen);
}
D3D11_SUBRESOURCE_DATA indata;
indata.pSysMem = randValues;
indata.SysMemPitch = wind * sizeof(XMFLOAT4);
indata.SysMemSlicePitch = 0;
D3D11_TEXTURE1D_DESC texDesc;
texDesc.Width = wind;
texDesc.MipLevels = 1;
texDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
texDesc.Usage = D3D11_USAGE_IMMUTABLE;
texDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
texDesc.CPUAccessFlags = 0;
texDesc.MiscFlags = 0;
texDesc.ArraySize = 1;
ID3D11Texture1D* randomTex = 0;
HRESULT hr;
hr = dev->CreateTexture1D(&texDesc, &indata, &randomTex);
if (ShaderRandTex)
ShaderRandTex->Release();
D3D11_SHADER_RESOURCE_VIEW_DESC viewD;
viewD.Format = texDesc.Format;
viewD.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D;
viewD.Texture1D.MipLevels = texDesc.MipLevels;
viewD.Texture1D.MostDetailedMip = 0;
hr = dev->CreateShaderResourceView(randomTex, &viewD, &ShaderRandTex);
devCon->PSSetShaderResources(4, 1, &ShaderRandTex);
randomTex->Release();
}
//create a random texture used to be sampled in the Shader
static ID3D11ShaderResourceView* CreateRandomeTexture(ID3D11Device* device )
{
DirectX::XMFLOAT4 randomValues[1024];
//Fill the Data for the Random texture
for (unsigned int i = 0; i < 1024; ++i)
{
randomValues[i].x = Randomizer::GetRandom(-1, 1);
randomValues[i].y = Randomizer::GetRandom(-1, 1);
randomValues[i].z = Randomizer::GetRandom(-1, 1);
randomValues[i].w = Randomizer::GetRandom(-1, 1);
}
D3D11_SUBRESOURCE_DATA initData;
initData.SysMemPitch = 1024 * sizeof(XMFLOAT4);
initData.pSysMem = randomValues;
initData.SysMemSlicePitch = 0;
D3D11_TEXTURE1D_DESC texDesc;
texDesc.Width = 1024;
texDesc.MipLevels = 1;
texDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
texDesc.Usage = D3D11_USAGE_IMMUTABLE;
texDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
texDesc.CPUAccessFlags = 0;
texDesc.MiscFlags = 0;
texDesc.ArraySize = 1;
ID3D11Texture1D* randomTex = 0;
device->CreateTexture1D(&texDesc, &initData, &randomTex);
//
// Create the resource view.
//
D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc;
viewDesc.Format = texDesc.Format;
viewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D;
viewDesc.Texture1D.MipLevels = texDesc.MipLevels;
viewDesc.Texture1D.MostDetailedMip = 0;
ID3D11ShaderResourceView* randomTexSRV = 0;
device->CreateShaderResourceView(randomTex, &viewDesc, &randomTexSRV);
randomTex->Release();
return randomTexSRV;
}
//
// FUNCTION: GraphicsDeviceInterface::Initialize()
//
// PURPOSE: Initializes Direct3D
//
bool GraphicsDeviceInterface::Initialize(HWND hWnd, WindowSize* wind) {
HRESULT hResult;
// Clear the struct
ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));
// Set the swap chain values
scd.BufferCount = 1; // one back buffer
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; // use 32 bit color
scd.BufferDesc.Width = wind->getWidth(); // set width using windowSize object
scd.BufferDesc.Height = wind->getHeight(); // set height using windowSize object
scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; // swap chain is output
scd.OutputWindow = hWnd; // window to render into
scd.SampleDesc.Count = 4; // use 4 multisamples for antialiasing
scd.Windowed = wind->getWindowed(); // Sets windowed mode
scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; // Allow full-screen switching
// Create the device, context, and swap chain
hResult = D3D11CreateDeviceAndSwapChain(NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
NULL, //D3D_FEATURE_LEVEL_10_0,
NULL,
NULL,
D3D11_SDK_VERSION,
&scd,
&m_Swapchain,
&m_Device,
NULL,
&m_Context);
if (hResult != S_OK)
{
return FALSE;
}
// Retrieves the IDXGIFactory that created "m_Device"
IDXGIDevice *pDXGIDevice;
m_Device->QueryInterface(__uuidof(IDXGIDevice), (void **)&pDXGIDevice);
IDXGIAdapter *pDXGIAdapter;
pDXGIDevice->GetParent(__uuidof(IDXGIAdapter), (void **)&pDXGIAdapter);
IDXGIFactory *pDXGIFactory;
pDXGIAdapter->GetParent(__uuidof(IDXGIFactory), (void **)&pDXGIFactory);
// Disables the use of Alt-Enter to switch between fullscreen/windowed
pDXGIFactory->MakeWindowAssociation(hWnd, DXGI_MWA_NO_ALT_ENTER);
// Resized the target (window or screen resolution) and back buffers
m_Swapchain->ResizeTarget(&scd.BufferDesc);
m_Swapchain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, scd.Flags);
// Get the back buffer address
ID3D11Texture1D *pBackBuffer;
m_Swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
// Use the back buffer address to create a render target
m_Device->CreateRenderTargetView(pBackBuffer, NULL, &m_BackBuffer);
pBackBuffer->Release();
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
depthBufferDesc.Width = wind->getWidth();
depthBufferDesc.Height = wind->getHeight();
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 4;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
m_Device->CreateTexture2D(&depthBufferDesc, NULL, &m_DepthStencilBuffer);
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
m_Device->CreateDepthStencilState(&depthStencilDesc, &m_DepthStencilState);
m_Context->OMSetDepthStencilState(m_DepthStencilState, 1);
// Initailze the depth stencil view.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
m_Device->CreateDepthStencilView(m_DepthStencilBuffer, NULL, &m_DepthStencilView);
// set the render target as the back buffer
m_Context->OMSetRenderTargets(1, &m_BackBuffer, m_DepthStencilView);
// Set the viewport using windowSize object
D3D11_VIEWPORT viewport;
ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.Width = (float)wind->getWidth();
viewport.Height = (float)wind->getHeight();
m_Context->RSSetViewports(1, &viewport);
// Setup the projection matrix.
float fieldOfView = (float)D3DX_PI / 4.0f;
float screenAspect = (float)wind->getWidth() / (float)wind->getHeight();
// TODO: Make constants for screen depth and screen near.
// Create the projection matrix for 3D rendering.
D3DXMatrixPerspectiveFovLH(&m_projMatrix, fieldOfView, screenAspect, 0.1f, 1000.0f);
InitPipeline();
InitGraphics();
return TRUE;
}
//--------------------------------------------------------------------------------------
static HRESULT CreateD3DResources( _In_ ID3D11Device1* d3dDevice,
_In_ ID3DXboxPerformanceDevice* perfDevice,
_In_ const DDS_HEADER_XBOX* xboxext,
_In_ uint32_t width,
_In_ uint32_t height,
_In_ uint32_t depth,
_In_ uint32_t mipCount,
_In_ uint32_t arraySize,
_In_ bool forceSRGB,
_In_ bool isCubeMap,
_In_ void* grfxMemory,
_Outptr_opt_ ID3D11Resource** texture,
_Outptr_opt_ ID3D11ShaderResourceView** textureView )
{
if ( !d3dDevice || !perfDevice || !grfxMemory )
return E_POINTER;
HRESULT hr = E_FAIL;
DXGI_FORMAT format = xboxext->dxgiFormat;
if ( forceSRGB )
{
format = MakeSRGB( format );
}
switch ( xboxext->resourceDimension )
{
case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
{
D3D11_TEXTURE1D_DESC desc;
memset( &desc, 0, sizeof(desc) );
desc.Width = static_cast<UINT>( width );
desc.MipLevels = static_cast<UINT>( mipCount );
desc.ArraySize = static_cast<UINT>( arraySize );
desc.Format = format;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
ID3D11Texture1D* tex = nullptr;
hr = perfDevice->CreatePlacementTexture1D( &desc, xboxext->tileMode, 0, grfxMemory, &tex );
if (SUCCEEDED( hr ) && tex != 0)
{
if (textureView != 0)
{
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
memset( &SRVDesc, 0, sizeof( SRVDesc ) );
SRVDesc.Format = format;
if (arraySize > 1)
{
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY;
SRVDesc.Texture1DArray.MipLevels = desc.MipLevels;
SRVDesc.Texture1DArray.ArraySize = static_cast<UINT>( arraySize );
}
else
{
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D;
SRVDesc.Texture1D.MipLevels = desc.MipLevels;
}
hr = d3dDevice->CreateShaderResourceView( tex,
&SRVDesc,
textureView
);
if ( FAILED(hr) )
{
tex->Release();
return hr;
}
}
if (texture != 0)
{
*texture = tex;
}
else
{
SetDebugObjectName(tex, "XboxDDSTextureLoader");
tex->Release();
}
}
}
break;
case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
{
D3D11_TEXTURE2D_DESC desc;
memset( &desc, 0, sizeof(desc) );
desc.Width = static_cast<UINT>( width );
desc.Height = static_cast<UINT>( height );
desc.MipLevels = static_cast<UINT>( mipCount );
desc.ArraySize = static_cast<UINT>( arraySize );
desc.Format = format;
desc.SampleDesc.Count = 1;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
desc.MiscFlags = ( isCubeMap ) ? D3D11_RESOURCE_MISC_TEXTURECUBE : 0;
ID3D11Texture2D* tex = nullptr;
hr = perfDevice->CreatePlacementTexture2D( &desc, xboxext->tileMode, 0, grfxMemory, &tex );
if (SUCCEEDED( hr ) && tex != 0)
{
if (textureView != 0)
{
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
memset( &SRVDesc, 0, sizeof( SRVDesc ) );
SRVDesc.Format = format;
if ( isCubeMap )
{
if (arraySize > 6)
{
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY;
SRVDesc.TextureCubeArray.MipLevels = desc.MipLevels;
// Earlier we set arraySize to (NumCubes * 6)
SRVDesc.TextureCubeArray.NumCubes = static_cast<UINT>( arraySize / 6 );
}
else
{
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
SRVDesc.TextureCube.MipLevels = desc.MipLevels;
}
}
else if (arraySize > 1)
{
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
SRVDesc.Texture2DArray.MipLevels = desc.MipLevels;
SRVDesc.Texture2DArray.ArraySize = static_cast<UINT>( arraySize );
}
else
{
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
SRVDesc.Texture2D.MipLevels = desc.MipLevels;
}
hr = d3dDevice->CreateShaderResourceView( tex,
&SRVDesc,
textureView
);
if ( FAILED(hr) )
{
tex->Release();
return hr;
}
}
if (texture != 0)
{
*texture = tex;
}
else
{
SetDebugObjectName(tex, "XboxDDSTextureLoader");
tex->Release();
}
}
}
break;
case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
{
D3D11_TEXTURE3D_DESC desc;
memset( &desc, 0, sizeof(desc) );
desc.Width = static_cast<UINT>( width );
desc.Height = static_cast<UINT>( height );
desc.Depth = static_cast<UINT>( depth );
desc.MipLevels = static_cast<UINT>( mipCount );
desc.Format = format;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
ID3D11Texture3D* tex = nullptr;
hr = perfDevice->CreatePlacementTexture3D( &desc, xboxext->tileMode, 0, grfxMemory, &tex );
if (SUCCEEDED( hr ) && tex != 0)
{
if (textureView != 0)
{
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
memset( &SRVDesc, 0, sizeof( SRVDesc ) );
SRVDesc.Format = format;
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
SRVDesc.Texture3D.MipLevels = desc.MipLevels;
hr = d3dDevice->CreateShaderResourceView( tex,
&SRVDesc,
textureView
);
if ( FAILED(hr) )
{
tex->Release();
return hr;
}
}
if (texture != 0)
{
*texture = tex;
}
else
{
SetDebugObjectName(tex, "XboxDDSTextureLoader");
tex->Release();
}
}
}
break;
}
return hr;
}
