HRESULT D3DGrid11::Render(Scene* pScene)
{
HRESULT hr;
GridRenderComponent* grid = static_cast<GridRenderComponent*>(m_RenderComponent);
m_PixelShader.SetTexture(grid->GetTextureResource());
V_RETURN(m_VertexShader.SetupRender(pScene, this));
V_RETURN(m_PixelShader.SetupRender(pScene, this));
// set vertex buffer
UINT stride = sizeof(D3D11Vertex_UnlitTextured);
UINT offset = 0;
DXUTGetD3D11DeviceContext()->IASetVertexBuffers(0, 1, &m_pVertexBuffer, &stride, &offset);
// set index buffer
DXUTGetD3D11DeviceContext()->IASetIndexBuffer(m_pIndexBuffer, DXGI_FORMAT_R16_UINT, 0);
// set primitive topology
DXUTGetD3D11DeviceContext()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// draw the polygon
DXUTGetD3D11DeviceContext()->DrawIndexed(m_NumPolys * 3, 0, 0);
return S_OK;
}
void D3DLineDrawer11::DrawLine(const Vec3& from, const Vec3& to, const Color& color)
{
HRESULT hr;
shared_ptr<Scene> pScene = g_pApp->GetHumanView()->m_pScene;
shared_ptr<IRenderer> pRenderer = pScene->GetRenderer();
if (FAILED(m_LineDrawerShader.SetupRender(&(*pScene))))
return;
m_LineDrawerShader.SetDiffuse("art\\grid.dds", color);
UINT stride = sizeof(Vec3);
UINT offset = 0;
// map the vertex buffer into a D3D11 mapped resource
D3D11_MAPPED_SUBRESOURCE mappedResource;
V(DXUTGetD3D11DeviceContext()->Map(m_pVertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource));
// fill in the vertex buffer with the from and to params
Vec3* pVertices = (Vec3*)mappedResource.pData;
pVertices[0] = from;
pVertices[1] = to;
// store the vertices
m_Verts[0] = from;
m_Verts[1] = to;
DXUTGetD3D11DeviceContext()->Unmap(m_pVertexBuffer, 0);
// send the vertices to the GPU and draw
DXUTGetD3D11DeviceContext()->IASetVertexBuffers(0, 1, &m_pVertexBuffer, &stride, &offset);
DXUTGetD3D11DeviceContext()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
DXUTGetD3D11DeviceContext()->Draw(2, 0);
}
void GlobalAppState::WaitForGPU()
{
DXUTGetD3D11DeviceContext()->Flush();
DXUTGetD3D11DeviceContext()->End(m_pQuery);
DXUTGetD3D11DeviceContext()->Flush();
while (S_OK != DXUTGetD3D11DeviceContext()->GetData(m_pQuery, NULL, 0, 0));
}
void HumanView::VOnRender(double fTime, float fElapsedTime )
{
m_currTick = timeGetTime();
if (m_currTick == m_lastDraw)
return;
// It is time to draw ?
if( (m_currTick - m_lastDraw) > SCREEN_REFRESH_RATE )
{
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
float ClearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
ID3D11RenderTargetView* pRTV = DXUTGetD3D11RenderTargetView();
pd3dImmediateContext->ClearRenderTargetView( pRTV, ClearColor );
ID3D11DepthStencilView* pDSV = DXUTGetD3D11DepthStencilView();
pd3dImmediateContext->ClearDepthStencilView( pDSV, D3D11_CLEAR_DEPTH, 1.0, 0 );
m_ScreenElements.sort(SortBy_SharedPtr_Content<IScreenElement>());
for(ScreenElementList::iterator i=m_ScreenElements.begin(); i!=m_ScreenElements.end(); ++i)
{
(*i)->VOnRender(fTime, fElapsedTime);
}
// record the last successful paint
m_lastDraw = m_currTick;
}
}
void RSMRenderer::RenderSpotRSMs( int NumSpotLights, const GuiState& CurrentGuiState, const Scene& Scene, const CommonUtil& CommonUtil )
{
AMDProfileEvent( AMD_PROFILE_RED, L"SpotRSM" );
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
D3D11_VIEWPORT oldVp[ 8 ];
UINT numVPs = 1;
pd3dImmediateContext->RSGetViewports( &numVPs, oldVp );
ID3D11RenderTargetView* pRTVs[] = { m_SpotAtlas.m_pNormalRTV, m_SpotAtlas.m_pDiffuseRTV };
const int NumTargets = ARRAYSIZE( pRTVs );
float clearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
pd3dImmediateContext->ClearDepthStencilView( m_SpotAtlas.m_pDepthDSV, D3D11_CLEAR_DEPTH, 1.0f, 0 );
pd3dImmediateContext->ClearRenderTargetView( m_SpotAtlas.m_pNormalRTV, clearColor );
pd3dImmediateContext->ClearRenderTargetView( m_SpotAtlas.m_pDiffuseRTV, clearColor );
pd3dImmediateContext->OMSetRenderTargets( NumTargets, pRTVs, m_SpotAtlas.m_pDepthDSV );
D3D11_VIEWPORT vps[ 8 ];
for ( int i = 0; i < NumTargets; i++ )
{
vps[ i ].Width = gRSMSpotResolution;
vps[ i ].Height = gRSMSpotResolution;
vps[ i ].MinDepth = 0.0f;
vps[ i ].MaxDepth = 1.0f;
vps[ i ].TopLeftY = 0.0f;
vps[ i ].TopLeftX = 0.0f;
}
HRESULT hr;
D3D11_MAPPED_SUBRESOURCE MappedSubresource;
V( pd3dImmediateContext->Map( m_pSpotInvViewProjBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedSubresource ) );
memcpy(MappedSubresource.pData, LightUtil::GetShadowCastingSpotLightViewProjInvTransposedArray(), sizeof(XMMATRIX)*MAX_NUM_SHADOWCASTING_SPOTS);
pd3dImmediateContext->Unmap( m_pSpotInvViewProjBuffer, 0 );
const XMMATRIX* SpotLightViewProjArray = LightUtil::GetShadowCastingSpotLightViewProjTransposedArray();
for ( int i = 0; i < NumSpotLights; i++ )
{
for ( int j = 0; j < NumTargets; j++ )
{
vps[ j ].TopLeftX = (float)i * gRSMSpotResolution;
}
pd3dImmediateContext->RSSetViewports( NumTargets, vps );
m_CameraCallback( SpotLightViewProjArray[i] );
RenderRSMScene( CurrentGuiState, Scene, CommonUtil );
}
pd3dImmediateContext->RSSetViewports( 1, oldVp );
ID3D11RenderTargetView* pNullRTVs[] = { 0, 0, 0 };
pd3dImmediateContext->OMSetRenderTargets( ARRAYSIZE( pNullRTVs ), pNullRTVs, 0 );
}
HRESULT DebugText::OnD3D11CreateDevice( ID3D11Device* pd3dDevice, CDXUTDialogResourceManager* dxutResourceManager )
{
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
dxutTextHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, dxutResourceManager, DXUTLINEHEIGHT );
return S_OK;
}
HRESULT CALLBACK GameApp::OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN(g_pApp->g_DialogResourceManager.OnD3D11CreateDevice(pd3dDevice, pd3dImmediateContext));
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK DXUTHelper::AppD3D11CreateDevice(ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext)
{
auto pD3D11DeviceContext = DXUTGetD3D11DeviceContext();
g_RenderSystem.Init(pd3dDevice, pD3D11DeviceContext);
return S_OK;
}
//
// D3DShaderMeshNode11::VRender - Chapter 16, page 564
//
HRESULT D3DShaderMeshNode11::VRender(Scene *pScene)
{
HRESULT hr;
V_RETURN (m_VertexShader.SetupRender(pScene, this) );
V_RETURN (m_PixelShader.SetupRender(pScene, this) );
//Get the Mesh
Resource resource(m_sdkMeshFileName);
shared_ptr<ResHandle> pResourceHandle = g_pApp->m_ResCache->GetHandle(&resource);
shared_ptr<D3DSdkMeshResourceExtraData11> extra = static_pointer_cast<D3DSdkMeshResourceExtraData11>(pResourceHandle->GetExtra());
// FUTURE WORK - this code WON'T be able to find texture resources referred to by the sdkmesh file
// in the Resource cache.
//IA setup
UINT Strides[1];
UINT Offsets[1];
ID3D11Buffer* pVB[1];
pVB[0] = extra->m_Mesh11.GetVB11( 0, 0 );
Strides[0] = ( UINT )extra->m_Mesh11.GetVertexStride( 0, 0 );
Offsets[0] = 0;
DXUTGetD3D11DeviceContext()->IASetVertexBuffers( 0, 1, pVB, Strides, Offsets );
DXUTGetD3D11DeviceContext()->IASetIndexBuffer( extra->m_Mesh11.GetIB11( 0 ), extra->m_Mesh11.GetIBFormat11( 0 ), 0 );
//Render
D3D11_PRIMITIVE_TOPOLOGY PrimType;
for( UINT subset = 0; subset < extra->m_Mesh11.GetNumSubsets( 0 ); ++subset )
{
// Get the subset
SDKMESH_SUBSET *pSubset = extra->m_Mesh11.GetSubset( 0, subset );
PrimType = CDXUTSDKMesh::GetPrimitiveType11( ( SDKMESH_PRIMITIVE_TYPE )pSubset->PrimitiveType );
DXUTGetD3D11DeviceContext()->IASetPrimitiveTopology( PrimType );
ID3D11ShaderResourceView* pDiffuseRV = extra->m_Mesh11.GetMaterial( pSubset->MaterialID )->pDiffuseRV11;
DXUTGetD3D11DeviceContext()->PSSetShaderResources( 0, 1, &pDiffuseRV );
DXUTGetD3D11DeviceContext()->DrawIndexed( ( UINT )pSubset->IndexCount, 0, ( UINT )pSubset->VertexStart );
}
return S_OK;
}
Renderer::Renderer( ID3D11Device *pd3dDevice )
{
pd3dDevice_ = pd3dDevice;
pd3dImmediateContext_ = DXUTGetD3D11DeviceContext();
TR_ = new RenderTargets(pd3dDevice);
RS_ = new RasterStates(pd3dDevice);
SAMP_ = new SamplerStates(pd3dDevice);
DSS_ = new DepthStencilStates(pd3dDevice);
Shader_ = new Shader(pd3dDevice, pd3dImmediateContext_);
}
//
// D3DSkyNode11::VRender - Chapter 16, page 559
//
HRESULT D3DSkyNode11::VRender(Scene *pScene)
{
HRESULT hr;
V_RETURN (m_VertexShader.SetupRender(pScene, this) );
V_RETURN (m_PixelShader.SetupRender(pScene, this) );
// Set vertex buffer
UINT stride = sizeof( D3D11Vertex_UnlitTextured );
UINT offset = 0;
DXUTGetD3D11DeviceContext()->IASetVertexBuffers( 0, 1, &m_pVertexBuffer, &stride, &offset );
// Set index buffer
DXUTGetD3D11DeviceContext()->IASetIndexBuffer( m_pIndexBuffer, DXGI_FORMAT_R16_UINT, 0 );
// Set primitive topology
DXUTGetD3D11DeviceContext()->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
for (DWORD side = 0; side < m_sides; side++)
{
// FUTURTE WORK: A good optimization would be to transform the camera's
// world look vector into local space, and do a dot product. If the
// result is positive, we shouldn't draw the side since it has to be
// behind the camera!
// Sky boxes aren't culled by the normal mechanism
/***
// [mrmike] - This was slightly changed post press, look at the lines below this commented out code
const char *suffix[] = { "_n.jpg", "_e.jpg", "_s.jpg", "_w.jpg", "_u.jpg" };
name += suffix[side];
****/
std::string name = GetTextureName(side);
m_PixelShader.SetTexture(name.c_str());
DXUTGetD3D11DeviceContext()->DrawIndexed( 6, side * 6, 0 );
}
return S_OK;
}
HRESULT D3DShaderMeshNode11::Render(Scene* pScene)
{
HRESULT hr;
V_RETURN(m_VertexShader.SetupRender(pScene, this));
V_RETURN(m_PixelShader.SetupRender(pScene, this));
// get the mesh from cache
Resource resource(m_sdkMeshFileName);
shared_ptr<ResHandle> pResourceHandle = g_pApp->m_ResCache->GetHandle(&resource);
shared_ptr<D3DSdkMeshResourceExtraData11> extra = static_pointer_cast<D3DSdkMeshResourceExtraData11>(pResourceHandle->GetExtra());
// set up buffers
UINT strides[1];
UINT offsets[1];
ID3D11Buffer* pVertexBuffer[1];
pVertexBuffer[0] = extra->m_Mesh11.GetVB11(0, 0);
strides[0] = (UINT)extra->m_Mesh11.GetVertexStride(0, 0);
offsets[0] = 0;
DXUTGetD3D11DeviceContext()->IASetVertexBuffers(0, 1, pVertexBuffer, strides, offsets);
DXUTGetD3D11DeviceContext()->IASetIndexBuffer(extra->m_Mesh11.GetIB11(0), extra->m_Mesh11.GetIBFormat11(0), 0);
// render
D3D11_PRIMITIVE_TOPOLOGY primType;
for (UINT subset = 0; subset < extra->m_Mesh11.GetNumSubsets(0); ++subset)
{
SDKMESH_SUBSET* pSubset = extra->m_Mesh11.GetSubset(0, subset);
primType = CDXUTSDKMesh::GetPrimitiveType11((SDKMESH_PRIMITIVE_TYPE)pSubset->PrimitiveType);
DXUTGetD3D11DeviceContext()->IASetPrimitiveTopology(primType);
ID3D11ShaderResourceView* pDiffuseRV = extra->m_Mesh11.GetMaterial(pSubset->MaterialID)->pDiffuseRV11;
DXUTGetD3D11DeviceContext()->PSSetShaderResources(0, 1, &pDiffuseRV);
DXUTGetD3D11DeviceContext()->DrawIndexed((UINT)pSubset->IndexCount, 0, (UINT)pSubset->VertexStart);
}
return S_OK;
}
static HRESULT CALLBACK on_device_create( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
g_render_context.reset(new c_render_system_context(DXUTGetD3D11Device(),
DXUTGetD3D11DeviceContext(),
DXUTGetDXGIBackBufferSurfaceDesc(),
DXUTGetDXGISwapChain()));
g_scene->on_create_resource(g_render_context);
g_resolver->on_create_resource(g_render_context);
return S_OK;
}
HRESULT CALLBACK OnD3D11CreateDevice(ID3D11Device* d3dDevice, const DXGI_SURFACE_DESC* backBufferSurfaceDesc,
void* userContext)
{
ID3D11DeviceContext* d3dDeviceContext = DXUTGetD3D11DeviceContext();
gDialogResourceManager.OnD3D11CreateDevice(d3dDevice, d3dDeviceContext);
gD3DSettingsDlg.OnD3D11CreateDevice(d3dDevice);
gTextHelper = new CDXUTTextHelper(d3dDevice, d3dDeviceContext, &gDialogResourceManager, 15);
gViewerCamera.SetRotateButtons(true, false, false);
gViewerCamera.SetDrag(true);
gViewerCamera.SetEnableYAxisMovement(true);
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that depend on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK DXUTHelper::AppD3D11ResizedSwapChain(ID3D11Device* pd3dDevice, IDXGISwapChain* pSwapChain,
const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext)
{
// Setup the projection parameters
float fWidth = static_cast<float>(pBackBufferSurfaceDesc->Width);
float fHeight = static_cast<float>(pBackBufferSurfaceDesc->Height);
auto pD3D11DeviceContext = DXUTGetD3D11DeviceContext();
g_RenderSystem.init_camera(fWidth, fHeight, pD3D11DeviceContext);
return S_OK;
}
void MeshSkeletal::Render( CompileShader* pshader )
{
if (pshader == nullptr)
return;
DXUTGetD3D11DeviceContext()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
UINT stride = sizeof(VERTEXSKELETAL);
UINT offset = 0;
for (int i = 0; i < m_model.numSubsets; i++)
{
//인덱스 버퍼
DXUTGetD3D11DeviceContext()->IASetIndexBuffer(m_model.subsets[i].indexBuff, DXGI_FORMAT_R32_UINT, 0);
//버텍스 버퍼
DXUTGetD3D11DeviceContext()->IASetVertexBuffers(0, 1, &m_model.subsets[i].vertBuff, &stride, &offset);
//텍스쳐 설정
DXUTGetD3D11DeviceContext()->PSSetShaderResources(0, 1, &m_textures[m_model.subsets[i].texArrayIndex]);
//그리기
DXUTGetD3D11DeviceContext()->DrawIndexed(m_model.subsets[i].indices.size(), 0, 0);
}
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
vegetationRendering = new VegetationRendering();
Window::setHandle(DXUTGetHWND());
ID3D11DeviceContext* deviceContext = DXUTGetD3D11DeviceContext();
dialogResourceManager.OnD3D11CreateDevice(pd3dDevice, deviceContext);
textHelper = CDXUTTextHelper(pd3dDevice, deviceContext, &dialogResourceManager, 30);
vegetationRendering->init(pd3dDevice);
return S_OK;
}
void CUDARayCastSDF::rayIntervalSplatting(const HashData& hashData, const HashParams& hashParams, const DepthCameraData& cameraData, const mat4f& lastRigidTransform)
{
if (hashParams.m_numOccupiedBlocks == 0) return;
if (m_params.m_maxNumVertices <= 6*hashParams.m_numOccupiedBlocks) { // 6 verts (2 triangles) per block
MLIB_EXCEPTION("not enough space for vertex buffer for ray interval splatting");
}
m_params.m_numOccupiedSDFBlocks = hashParams.m_numOccupiedBlocks;
m_params.m_viewMatrix = MatrixConversion::toCUDA(lastRigidTransform.getInverse());
m_params.m_viewMatrixInverse = MatrixConversion::toCUDA(lastRigidTransform);
//m_data.updateParams(m_params); // !!! debugging
m_rayIntervalSplatting.rayIntervalSplatting(DXUTGetD3D11DeviceContext(), hashData, cameraData, m_data, m_params, m_params.m_numOccupiedSDFBlocks*6);
}
int RSMRenderer::ReadbackNumVPLs()
{
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
int NumVPLs = 0;
pd3dImmediateContext->CopyStructureCount( m_pCPUReadbackConstantBuffer, 0, m_pVPLBufferCenterAndRadiusUAV );
D3D11_MAPPED_SUBRESOURCE resource;
if ( pd3dImmediateContext->Map( m_pCPUReadbackConstantBuffer, 0, D3D11_MAP_READ, 0, &resource ) == S_OK )
{
NumVPLs = *( (int*)resource.pData );
pd3dImmediateContext->Unmap( m_pCPUReadbackConstantBuffer, 0 );
}
return NumVPLs;
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependent on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice(ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* /*pBackBufferSurfaceDesc*/,
void* /*pUserContext*/)
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN(g_DialogResourceManager.OnD3D11CreateDevice(pd3dDevice, pd3dImmediateContext));
V_RETURN(g_D3DSettingsDlg.OnD3D11CreateDevice(pd3dDevice));
g_pTxtHelper = new CDXUTTextHelper(pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15);
V_RETURN(g_Scene.OnD3D11CreateDevice(pd3dDevice));
// Setup the camera
XMVECTOR vecEye = XMVectorSet(0.0f, 0.5f, -3.0f, 0);
XMVECTOR vecAt = XMVectorSet(0.0f, 0.0f, 0.0f, 0);
g_Camera.SetViewParams(vecEye, vecAt);
g_OIT.OnD3D11CreateDevice(pd3dDevice);
return S_OK;
}
void RSMRenderer::RenderRSMScene( const GuiState& CurrentGuiState, const Scene& Scene, const CommonUtil& CommonUtil )
{
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
pd3dImmediateContext->OMSetDepthStencilState( CommonUtil.GetDepthStencilState(DEPTH_STENCIL_STATE_DEPTH_LESS), 0x00 );
pd3dImmediateContext->IASetInputLayout( m_pRSMLayout );
pd3dImmediateContext->VSSetShader( m_pRSMVS, NULL, 0 );
pd3dImmediateContext->PSSetShader( m_pRSMPS, NULL, 0 );
pd3dImmediateContext->PSSetSamplers( 0, 1, CommonUtil.GetSamplerStateParam(SAMPLER_STATE_POINT) );
// Draw the main scene
Scene.m_pSceneMesh->Render( pd3dImmediateContext, 0, 1 );
// Draw the grid objects (i.e. the "lots of triangles" system)
for( int i = 0; i < CurrentGuiState.m_nNumGridObjects; i++ )
{
CommonUtil.DrawGrid(i, CurrentGuiState.m_nGridObjectTriangleDensity);
}
// Skip the alpha-test geometry
}
void ShadowRenderer::RenderPointMap( int numShadowCastingPointLights )
{
AMDProfileEvent( AMD_PROFILE_RED, L"PointShadows" );
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
D3D11_VIEWPORT oldVp[ 8 ];
UINT numVPs = 1;
pd3dImmediateContext->RSGetViewports( &numVPs, oldVp );
D3D11_VIEWPORT vp;
vp.Width = gPointShadowResolution;
vp.Height = gPointShadowResolution;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
pd3dImmediateContext->ClearDepthStencilView( m_pPointAtlasView, D3D11_CLEAR_DEPTH, 1.0f, 0 );
ID3D11RenderTargetView* pNULLRTV = NULL;
pd3dImmediateContext->OMSetRenderTargets( 1, &pNULLRTV, m_pPointAtlasView );
const XMMATRIX (*PointLightViewProjArray)[6] = LightUtil::GetShadowCastingPointLightViewProjTransposedArray();
for ( int p = 0; p < numShadowCastingPointLights; p++ )
{
vp.TopLeftY = (float)p * gPointShadowResolution;
for ( int i = 0; i < 6; i++ )
{
m_CameraCallback( PointLightViewProjArray[p][i] );
vp.TopLeftX = (float)i * gPointShadowResolution;
pd3dImmediateContext->RSSetViewports( 1, &vp );
m_RenderCallback();
}
}
pd3dImmediateContext->RSSetViewports( 1, oldVp );
}
//--------------------------------------------------------------------------------------
// Initialization
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext )
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN( g_pDialogResourceManager->OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) );
g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, g_pDialogResourceManager, 15 );
V_RETURN( pd3dDevice->CreateVertexShader( g_ParticleVS, sizeof(g_ParticleVS), NULL, &g_pVertexShader ) );
V_RETURN( pd3dDevice->CreateGeometryShader( g_ParticleGS, sizeof(g_ParticleGS), NULL, &g_pGeometryShader ) );
V_RETURN( pd3dDevice->CreatePixelShader( g_ParticlePS, sizeof(g_ParticlePS), NULL, &g_pPixelShader ) );
// Create VB
D3D11_BUFFER_DESC bufferDesc;
ZeroMemory( &bufferDesc, sizeof(bufferDesc) );
bufferDesc.ByteWidth = sizeof(ParticleVertex) * FluidVertexBufferSize;
bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
V_RETURN( pd3dDevice->CreateBuffer( &bufferDesc, NULL, &g_pVertexBuffer ) );
bufferDesc.ByteWidth = sizeof(ConstantBuffer);
bufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
V_RETURN( pd3dDevice->CreateBuffer( &bufferDesc, NULL, &g_pConstantBuffer ) );
// Create the IA layout
D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
V_RETURN( pd3dDevice->CreateInputLayout( layout, _countof(layout), g_ParticleVS, sizeof(g_ParticleVS), &g_pVertexLayout ) );
return S_OK;
}
//--------------------------------------------------------------------------------------
// When the user changes scene, recreate these components as they are scene
// dependent.
//--------------------------------------------------------------------------------------
HRESULT CreateD3DComponents(ID3D11Device* pd3dDevice)
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN(g_DialogResourceManager.OnD3D11CreateDevice(pd3dDevice, pd3dImmediateContext));
V_RETURN(g_D3DSettingsDlg.OnD3D11CreateDevice(pd3dDevice));
g_pTxtHelper = new CDXUTTextHelper(pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15);
XMVECTOR vecEye = XMVectorSet(100.0f, 5.0f, 5.0f, 0);
XMVECTOR vecAt = XMVectorSet(0.0f, 0.0f, 0.0f, 0);
XMFLOAT3 vMin = XMFLOAT3(-1000.0f, -1000.0f, -1000.0f);
XMFLOAT3 vMax = XMFLOAT3(1000.0f, 1000.0f, 1000.0f);
g_ViewerCamera.SetViewParams(vecEye, vecAt);
g_ViewerCamera.SetRotateButtons(TRUE, FALSE, FALSE);
g_ViewerCamera.SetScalers(0.01f, 10.0f);
g_ViewerCamera.SetDrag(true);
g_ViewerCamera.SetEnableYAxisMovement(true);
g_ViewerCamera.SetClipToBoundary(TRUE, &vMin, &vMax);
g_ViewerCamera.FrameMove(0);
vecEye = XMVectorSet(-320.0f, 300.0f, -220.3f, 0);
vecAt = XMVectorSet(0.0f, 0.0f, 0.0f, 0);
g_LightCamera.SetViewParams(vecEye, vecAt);
g_LightCamera.SetRotateButtons(TRUE, FALSE, FALSE);
g_LightCamera.SetScalers(0.01f, 50.0f);
g_LightCamera.SetDrag(true);
g_LightCamera.SetEnableYAxisMovement(true);
g_LightCamera.SetClipToBoundary(TRUE, &vMin, &vMax);
g_LightCamera.SetProjParams(XM_PI / 4, 1.0f, 0.1f, 1000.0f);
g_LightCamera.FrameMove(0);
g_CascadedShadow.Init(pd3dDevice, pd3dImmediateContext,
g_pSelectedMesh, &g_ViewerCamera, &g_LightCamera, &g_CascadeConfig);
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice(ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext)
{
HRESULT hr;
DXUTTRACE(L"OnD3D11CreateDevice called\n");
SetCursor(LoadCursor(0, IDC_ARROW));
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext(); // does not addref
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice(pd3dDevice, pd3dImmediateContext) );
V_RETURN( g_SettingsDlg.OnD3D11CreateDevice(pd3dDevice) );
g_pTxtHelper = new CDXUTTextHelper(pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, g_TextLineHeight);
// Setup orbital camera
D3DXVECTOR3 vecEye(0.0f, 2.0f, 0.0f);
D3DXVECTOR3 vecAt (0.0f, 0.0f, 0.0f);
g_OrbitalCamera.SetViewParams(&vecEye, &vecAt);
g_OrbitalCamera.SetRadius(1.5f, 0.01f);
// Setup first-person camera
D3DXVECTOR3 sibenikVecEye(0.0960150138f, 0.0273544509f, -0.0185411610f);
D3DXVECTOR3 sibenikVecAt (-0.623801112f, -0.649074197f, -0.174454257f);
g_FirstPersonCamera.SetViewParams(&sibenikVecEye, &sibenikVecAt);
g_FirstPersonCamera.SetEnablePositionMovement(1);
g_FirstPersonCamera.SetScalers(0.001f, 0.05f);
// Load Scene3D.fx
g_pSceneRenderer.OnCreateDevice(pd3dDevice);
// Load meshes and bin files
LoadScenes(pd3dDevice);
GFSDK_SSAO_Status status;
status = g_AORenderer.Create(pd3dDevice);
assert(status == GFSDK_SSAO_OK);
return S_OK;
}
void RSMRenderer::GenerateVPLs( int NumSpotLights, int NumPointLights, const LightUtil& LightUtil )
{
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
ID3D11UnorderedAccessView* pUAVs[] = { m_pVPLBufferCenterAndRadiusUAV, m_pVPLBufferDataUAV };
// Clear the VPL counter
UINT InitialCounts[ 2 ] = { 0, 0 };
pd3dImmediateContext->CSSetUnorderedAccessViews( 0, ARRAYSIZE( pUAVs ), pUAVs, InitialCounts );
const int numThreadsX = 16;
const int numThreadsY = 16;
const int sampleKernel = 2;
if ( NumSpotLights > 0 )
{
ID3D11ShaderResourceView* pSRVs[] =
{
m_SpotAtlas.m_pDepthSRV,
m_SpotAtlas.m_pNormalSRV,
m_SpotAtlas.m_pDiffuseSRV,
m_pSpotInvViewProjBufferSRV,
*LightUtil.GetSpotLightBufferCenterAndRadiusSRVParam(LIGHTING_SHADOWS),
*LightUtil.GetSpotLightBufferColorSRVParam(LIGHTING_SHADOWS),
*LightUtil.GetSpotLightBufferSpotParamsSRVParam(LIGHTING_SHADOWS)
};
pd3dImmediateContext->CSSetShaderResources( 0, ARRAYSIZE( pSRVs ), pSRVs );
pd3dImmediateContext->CSSetShader( m_pGenerateSpotVPLsCS, 0, 0 );
int dispatchCountX = (NumSpotLights * gRSMSpotResolution/sampleKernel) / numThreadsX;
int dispatchCountY = (gRSMSpotResolution/sampleKernel) / numThreadsY;
pd3dImmediateContext->Dispatch( dispatchCountX, dispatchCountY, 1 );
ZeroMemory( pSRVs, sizeof( pSRVs ) );
pd3dImmediateContext->CSSetShaderResources( 0, ARRAYSIZE( pSRVs ), pSRVs );
}
if ( NumPointLights > 0 )
{
ID3D11ShaderResourceView* pSRVs[] =
{
m_PointAtlas.m_pDepthSRV,
m_PointAtlas.m_pNormalSRV,
m_PointAtlas.m_pDiffuseSRV,
m_pPointInvViewProjBufferSRV,
*LightUtil.GetPointLightBufferCenterAndRadiusSRVParam(LIGHTING_SHADOWS),
*LightUtil.GetPointLightBufferColorSRVParam(LIGHTING_SHADOWS)
};
pd3dImmediateContext->CSSetShaderResources( 0, ARRAYSIZE( pSRVs ), pSRVs );
pd3dImmediateContext->CSSetShader( m_pGeneratePointVPLsCS, 0, 0 );
int dispatchCountX = (6 * gRSMPointResolution/sampleKernel) / numThreadsX;
int dispatchCountY = (NumPointLights * gRSMPointResolution/sampleKernel) / numThreadsY;
pd3dImmediateContext->Dispatch( dispatchCountX, dispatchCountY, 1 );
ZeroMemory( pSRVs, sizeof( pSRVs ) );
pd3dImmediateContext->CSSetShaderResources( 0, ARRAYSIZE( pSRVs ), pSRVs );
}
ID3D11UnorderedAccessView* pNullUAVs[] = { NULL, NULL };
pd3dImmediateContext->CSSetUnorderedAccessViews( 0, ARRAYSIZE( pNullUAVs ), pNullUAVs, NULL );
// Copy the number of items counter from the UAV into a constant buffer for reading in the forward pass
pd3dImmediateContext->CopyStructureCount( m_pNumVPLsConstantBuffer, 0, m_pVPLBufferCenterAndRadiusUAV );
pd3dImmediateContext->CSSetConstantBuffers( 4, 1, &m_pNumVPLsConstantBuffer );
pd3dImmediateContext->PSSetConstantBuffers( 4, 1, &m_pNumVPLsConstantBuffer );
}
HRESULT DX11SceneRepHashSDF::CreateBuffers( ID3D11Device* pd3dDevice )
{
HRESULT hr = S_OK;
m_LastRigidTransform.setIdentity();
D3D11_BUFFER_DESC bDesc;
ZeroMemory(&bDesc, sizeof(D3D11_BUFFER_DESC));
bDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bDesc.Usage = D3D11_USAGE_DYNAMIC;
bDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bDesc.MiscFlags = 0;
bDesc.ByteWidth = sizeof(CB_VOXEL_HASH_SDF);
V_RETURN(pd3dDevice->CreateBuffer(&bDesc, NULL, &m_SDFVoxelHashCB));
D3D11_BUFFER_DESC descBUF;
D3D11_SHADER_RESOURCE_VIEW_DESC descSRV;
D3D11_UNORDERED_ACCESS_VIEW_DESC descUAV;
//create hash buffers/uav/srv (each element is a int3 -> (short3, short, int))
ZeroMemory(&descBUF, sizeof(D3D11_BUFFER_DESC));
descBUF.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
descBUF.Usage = D3D11_USAGE_DEFAULT;
descBUF.CPUAccessFlags = 0;
descBUF.MiscFlags = 0;
descBUF.ByteWidth = sizeof(int) * 3 * m_HashBucketSize * m_HashNumBuckets;
descBUF.StructureByteStride = sizeof(int);
ZeroMemory( &descSRV, sizeof(D3D11_SHADER_RESOURCE_VIEW_DESC) );
descSRV.Format = DXGI_FORMAT_R32_SINT;
descSRV.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
descSRV.Buffer.FirstElement = 0;
descSRV.Buffer.NumElements = 3 * m_HashBucketSize * m_HashNumBuckets;
ZeroMemory( &descUAV, sizeof(D3D11_UNORDERED_ACCESS_VIEW_DESC) );
descUAV.Format = DXGI_FORMAT_R32_SINT;
descUAV.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
descUAV.Buffer.FirstElement = 0;
descUAV.Buffer.NumElements = 3 * m_HashBucketSize * m_HashNumBuckets;
D3D11_SUBRESOURCE_DATA InitData;
ZeroMemory( &InitData, sizeof(D3D11_SUBRESOURCE_DATA) );
int* cpuNull = new int[3 * m_HashBucketSize * m_HashNumBuckets];
for (unsigned int i = 0; i < m_HashBucketSize * m_HashNumBuckets; i++) {
cpuNull[3*i+0] = 0;
cpuNull[3*i+1] = 0;
cpuNull[3*i+2] = -2; //marks free memory
}
InitData.pSysMem = cpuNull;
V_RETURN(pd3dDevice->CreateBuffer(&descBUF, &InitData, &m_Hash));
V_RETURN(pd3dDevice->CreateBuffer(&descBUF, &InitData, &m_HashCompactified));
SAFE_DELETE_ARRAY(cpuNull);
V_RETURN(pd3dDevice->CreateShaderResourceView(m_Hash, &descSRV, &m_HashSRV));
V_RETURN(pd3dDevice->CreateShaderResourceView(m_HashCompactified, &descSRV, &m_HashCompactifiedSRV));
V_RETURN(pd3dDevice->CreateUnorderedAccessView(m_Hash, &descUAV, &m_HashUAV));
V_RETURN(pd3dDevice->CreateUnorderedAccessView(m_HashCompactified, &descUAV, &m_HashCompactifiedUAV));
if (!m_JustHashAndNoSDFBlocks) {
//create hash mutex
ZeroMemory(&descBUF, sizeof(D3D11_BUFFER_DESC));
descBUF.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
descBUF.Usage = D3D11_USAGE_DEFAULT;
descBUF.CPUAccessFlags = 0;
descBUF.MiscFlags = 0;
descBUF.ByteWidth = sizeof(unsigned int) * m_HashNumBuckets;
descBUF.StructureByteStride = sizeof(unsigned int);
ZeroMemory( &descSRV, sizeof(D3D11_SHADER_RESOURCE_VIEW_DESC) );
descSRV.Format = DXGI_FORMAT_R32_UINT;
descSRV.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
descSRV.Buffer.FirstElement = 0;
descSRV.Buffer.NumElements = m_HashNumBuckets;
ZeroMemory( &descUAV, sizeof(D3D11_UNORDERED_ACCESS_VIEW_DESC) );
descUAV.Format = DXGI_FORMAT_R32_UINT;
descUAV.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
descUAV.Buffer.FirstElement = 0;
descUAV.Buffer.NumElements = m_HashNumBuckets;
ZeroMemory( &InitData, sizeof(D3D11_SUBRESOURCE_DATA) );
cpuNull = new int[m_HashNumBuckets];
for (unsigned int i = 0; i < m_HashNumBuckets; i++) {
cpuNull[i] = 0;
}
InitData.pSysMem = cpuNull;
V_RETURN(pd3dDevice->CreateBuffer(&descBUF, &InitData, &m_HashBucketMutex));
SAFE_DELETE_ARRAY(cpuNull);
V_RETURN(pd3dDevice->CreateShaderResourceView(m_HashBucketMutex, &descSRV, &m_HashBucketMutexSRV));
V_RETURN(pd3dDevice->CreateUnorderedAccessView(m_HashBucketMutex, &descUAV, &m_HashBucketMutexUAV));
//create heap (unsigned int -> ptr to data blocks)
ZeroMemory(&descBUF, sizeof(D3D11_BUFFER_DESC));
descBUF.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
descBUF.Usage = D3D11_USAGE_DEFAULT;
descBUF.CPUAccessFlags = 0;
descBUF.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
descBUF.ByteWidth = sizeof(unsigned int) * m_SDFNumBlocks;
descBUF.StructureByteStride = sizeof(unsigned int);
ZeroMemory (&descSRV, sizeof(D3D11_SHADER_RESOURCE_VIEW_DESC));
descSRV.Format = DXGI_FORMAT_UNKNOWN;
descSRV.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
descSRV.Buffer.FirstElement = 0;
descSRV.Buffer.NumElements = m_SDFNumBlocks;
ZeroMemory( &descUAV, sizeof(D3D11_UNORDERED_ACCESS_VIEW_DESC) );
descUAV.Format = DXGI_FORMAT_UNKNOWN;
descUAV.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
descUAV.Buffer.FirstElement = 0;
descUAV.Buffer.Flags = D3D11_BUFFER_UAV_FLAG_APPEND;
descUAV.Buffer.NumElements = m_SDFNumBlocks;
cpuNull = new int[m_SDFNumBlocks];
for (unsigned int i = 0; i < m_SDFNumBlocks; i++) {
cpuNull[i] = m_SDFNumBlocks - i - 1;
}
InitData.pSysMem = cpuNull;
V_RETURN(pd3dDevice->CreateBuffer(&descBUF, &InitData, &m_Heap));
SAFE_DELETE_ARRAY(cpuNull);
V_RETURN(pd3dDevice->CreateShaderResourceView(m_Heap, &descSRV, &m_HeapSRV));
V_RETURN(pd3dDevice->CreateUnorderedAccessView(m_Heap, &descUAV, &m_HeapUAV));
ZeroMemory( &descUAV, sizeof(D3D11_UNORDERED_ACCESS_VIEW_DESC) );
descUAV.Format = DXGI_FORMAT_UNKNOWN;
descUAV.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
descUAV.Buffer.FirstElement = 0;
descUAV.Buffer.Flags = 0;
descUAV.Buffer.NumElements = m_SDFNumBlocks;
V_RETURN(pd3dDevice->CreateUnorderedAccessView(m_Heap, &descUAV, &m_HeapStaticUAV))
ZeroMemory(&descBUF, sizeof(D3D11_BUFFER_DESC));
descBUF.BindFlags = 0;
descBUF.Usage = D3D11_USAGE_STAGING;
descBUF.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
descBUF.MiscFlags = 0;
descBUF.ByteWidth = sizeof(int);
V_RETURN(pd3dDevice->CreateBuffer(&descBUF, NULL, &m_HeapFreeCount));
unsigned int initalCount = m_SDFNumBlocks;
DXUTGetD3D11DeviceContext()->CSSetUnorderedAccessViews(0, 1, &m_HeapUAV, &initalCount);
ID3D11UnorderedAccessView* nullUAV[] = {NULL};
DXUTGetD3D11DeviceContext()->CSSetUnorderedAccessViews(0, 1, nullUAV, NULL);
//create sdf blocks (8x8x8 -> 8 byte per voxel: SDF part)
ZeroMemory(&descBUF, sizeof(D3D11_BUFFER_DESC));
descBUF.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
descBUF.Usage = D3D11_USAGE_DEFAULT;
descBUF.CPUAccessFlags = 0;
descBUF.MiscFlags = 0;
descBUF.ByteWidth = (sizeof(float)) * m_SDFBlockSize * m_SDFBlockSize * m_SDFBlockSize * m_SDFNumBlocks;
descBUF.StructureByteStride = sizeof(int);
ZeroMemory( &descSRV, sizeof(D3D11_SHADER_RESOURCE_VIEW_DESC) );
descSRV.Format = DXGI_FORMAT_R32_FLOAT;
descSRV.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
descSRV.Buffer.FirstElement = 0;
descSRV.Buffer.NumElements = m_SDFBlockSize * m_SDFBlockSize * m_SDFBlockSize * m_SDFNumBlocks;
ZeroMemory( &descUAV, sizeof(D3D11_UNORDERED_ACCESS_VIEW_DESC) );
descUAV.Format = DXGI_FORMAT_R32_FLOAT;
descUAV.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
descUAV.Buffer.FirstElement = 0;
descUAV.Buffer.NumElements = m_SDFBlockSize * m_SDFBlockSize * m_SDFBlockSize * m_SDFNumBlocks;
ZeroMemory( &InitData, sizeof(D3D11_SUBRESOURCE_DATA) );
cpuNull = new int[m_SDFBlockSize * m_SDFBlockSize * m_SDFBlockSize * m_SDFNumBlocks];
ZeroMemory(cpuNull, sizeof(int) * m_SDFBlockSize * m_SDFBlockSize * m_SDFBlockSize * m_SDFNumBlocks);
InitData.pSysMem = cpuNull;
V_RETURN(pd3dDevice->CreateBuffer(&descBUF, &InitData, &m_SDFBlocksSDF));
SAFE_DELETE_ARRAY(cpuNull);
V_RETURN(pd3dDevice->CreateShaderResourceView(m_SDFBlocksSDF, &descSRV, &m_SDFBlocksSDFSRV));
V_RETURN(pd3dDevice->CreateUnorderedAccessView(m_SDFBlocksSDF, &descUAV, &m_SDFBlocksSDFUAV));
//create sdf blocks (8x8x8 -> 8 byte per voxel: RGBW part)
ZeroMemory(&descBUF, sizeof(D3D11_BUFFER_DESC));
descBUF.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
descBUF.Usage = D3D11_USAGE_DEFAULT;
descBUF.CPUAccessFlags = 0;
descBUF.MiscFlags = 0;
descBUF.ByteWidth = sizeof(int) * m_SDFBlockSize * m_SDFBlockSize * m_SDFBlockSize * m_SDFNumBlocks;
descBUF.StructureByteStride = sizeof(int);
ZeroMemory( &descSRV, sizeof(D3D11_SHADER_RESOURCE_VIEW_DESC) );
descSRV.Format = DXGI_FORMAT_R32_SINT;
descSRV.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
descSRV.Buffer.FirstElement = 0;
descSRV.Buffer.NumElements = m_SDFBlockSize * m_SDFBlockSize * m_SDFBlockSize * m_SDFNumBlocks;
ZeroMemory( &descUAV, sizeof(D3D11_UNORDERED_ACCESS_VIEW_DESC) );
descUAV.Format = DXGI_FORMAT_R32_SINT;;
descUAV.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
descUAV.Buffer.FirstElement = 0;
descUAV.Buffer.NumElements = m_SDFBlockSize * m_SDFBlockSize * m_SDFBlockSize * m_SDFNumBlocks;
ZeroMemory( &InitData, sizeof(D3D11_SUBRESOURCE_DATA) );
cpuNull = new int[m_SDFBlockSize * m_SDFBlockSize * m_SDFBlockSize * m_SDFNumBlocks];
ZeroMemory(cpuNull, sizeof(int) * m_SDFBlockSize * m_SDFBlockSize * m_SDFBlockSize * m_SDFNumBlocks);
InitData.pSysMem = cpuNull;
V_RETURN(pd3dDevice->CreateBuffer(&descBUF, &InitData, &m_SDFBlocksRGBW));
SAFE_DELETE_ARRAY(cpuNull);
V_RETURN(pd3dDevice->CreateShaderResourceView(m_SDFBlocksRGBW, &descSRV, &m_SDFBlocksRGBWSRV));
V_RETURN(pd3dDevice->CreateUnorderedAccessView(m_SDFBlocksRGBW, &descUAV, &m_SDFBlocksRGBWUAV));
}
////////////////
// Compactify //
////////////////
//create hash buffers/uav/srv (each element is a int3 -> (short3, short, int))
ZeroMemory(&descBUF, sizeof(D3D11_BUFFER_DESC));
descBUF.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
descBUF.Usage = D3D11_USAGE_DEFAULT;
descBUF.CPUAccessFlags = 0;
descBUF.MiscFlags = 0;
descBUF.ByteWidth = sizeof(int) * m_HashBucketSize * m_HashNumBuckets;
descBUF.StructureByteStride = sizeof(int);
ZeroMemory( &descSRV, sizeof(D3D11_SHADER_RESOURCE_VIEW_DESC) );
descSRV.Format = DXGI_FORMAT_R32_SINT;
descSRV.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
descSRV.Buffer.FirstElement = 0;
descSRV.Buffer.NumElements = m_HashBucketSize * m_HashNumBuckets;
ZeroMemory( &descUAV, sizeof(D3D11_UNORDERED_ACCESS_VIEW_DESC) );
descUAV.Format = DXGI_FORMAT_R32_SINT;
descUAV.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
descUAV.Buffer.FirstElement = 0;
descUAV.Buffer.NumElements = m_HashBucketSize * m_HashNumBuckets;
ZeroMemory( &InitData, sizeof(D3D11_SUBRESOURCE_DATA) );
cpuNull = new int[m_HashBucketSize * m_HashNumBuckets];
for (unsigned int i = 0; i < m_HashBucketSize * m_HashNumBuckets; i++) {
cpuNull[i] = 0;
}
InitData.pSysMem = cpuNull;
V_RETURN(pd3dDevice->CreateBuffer(&descBUF, &InitData, &m_HashIntegrateDecision));
V_RETURN(pd3dDevice->CreateBuffer(&descBUF, &InitData, &m_HashIntegrateDecisionPrefix));
SAFE_DELETE_ARRAY(cpuNull);
V_RETURN(pd3dDevice->CreateShaderResourceView(m_HashIntegrateDecision, &descSRV, &m_HashIntegrateDecisionSRV));
V_RETURN(pd3dDevice->CreateUnorderedAccessView(m_HashIntegrateDecision, &descUAV, &m_HashIntegrateDecisionUAV));
V_RETURN(pd3dDevice->CreateShaderResourceView(m_HashIntegrateDecisionPrefix, &descSRV, &m_HashIntegrateDecisionPrefixSRV));
V_RETURN(pd3dDevice->CreateUnorderedAccessView(m_HashIntegrateDecisionPrefix, &descUAV, &m_HashIntegrateDecisionPrefixUAV));
return hr;
}
void HUD::init(ID3D11Device* graphicsDevice, Game* game)
{
dialog.Init(&dialogResourceManager);
dialog.SetCallback(HUD::onGuiEvent, game);
ID3D11DeviceContext* deviceContext = DXUTGetD3D11DeviceContext();
Terrain* terrain = game->terrain;
Camera* camera = game->camera;
textVisible = true;
textHelper = CDXUTTextHelper(graphicsDevice, deviceContext, &dialogResourceManager, 15);
unsigned width = 200;
unsigned height = 20;
unsigned delta = height * 2;
unsigned i = 1;
unsigned y = 0;
WCHAR sz[200];
float movementSpeed = camera->getMovementSpeed();
StringCchPrintf(sz, 200, L"Camera Movement: %.1f", movementSpeed);
dialog.AddStatic(CameraMovementStatic, sz, 0, y, width, height);
dialog.AddSlider(CameraMovementSlider, 0, y + height, width, height, 1, 500, (int)movementSpeed);
y += delta;
float bumpiness = terrain->getBumpiness();
StringCchPrintf(sz, 200, L"Bumpiness: %.1f", bumpiness);
dialog.AddStatic(BumpinessStatic, sz, 0, y, width, height);
dialog.AddSlider(BumpinessSlider, 0, y + height, width, height, 0, 2000, (int)bumpiness);
y += delta;
float minPixelPerTriangle = terrain->getMinPixelPerTriangle();
StringCchPrintf(sz, 200, L"Triangle Size: %.1f", minPixelPerTriangle);
dialog.AddStatic(MinPixelPerTriangleStatic, sz, 0, y, width, height);
dialog.AddSlider(MinPixelPerTriangleSlider, 0, y + height, width, height, 0, 20000, (int)(minPixelPerTriangle * 100.0f));
y += delta;
float roughnessModificator = terrain->getRoughnessModificator();
StringCchPrintf(sz, 200, L"Roughness Modificator: %.2f", roughnessModificator);
dialog.AddStatic(RoughnessModificatorStatic, sz, 0, y, width, height);
dialog.AddSlider(RoughnessModificatorSlider, 0, y + height, width, height, 0, 1000, (int)(roughnessModificator * 100.0f));
y += delta;
float textureRepeat = terrain->getColormapRepeat();
StringCchPrintf(sz, 200, L"Texture Repeat: %.1f", textureRepeat);
dialog.AddStatic(TextureRepeatStatic, sz, 0, y, width, height);
dialog.AddSlider(TextureRepeatSlider, 0, y + height, width, height, 1, 1024, (int)textureRepeat);
y += delta;
delta = (unsigned)(height * 1.2f);
dialog.AddCheckBox(WireframeCheckbox, L"Wireframe (TAB)", 0, y + delta * i++, width, height, game->isWireframe(), VK_TAB);
dialog.AddCheckBox(UpdateLODCheckbox, L"Update LOD", 0, y + delta * i++, width, height, !camera->isLocked());
dialog.AddCheckBox(CPUFrustumCullingCheckbox, L"CPU Frustum Culling", 0, y + delta * i++, width, height, terrain->getCPUFrustumCullingEnabled());
dialog.AddCheckBox(GPUFrustumCullingCheckbox, L"GPU Frustum Culling", 0, y + delta * i++, width, height, terrain->getGPUFrustumCullingEnabled());
dialog.AddCheckBox(SnapToTerrainCheckbox, L"Snap to Terrain", 0, y + delta * i++, width, height, !game->isFreeCamera());
dialog.AddCheckBox(ColormapCheckbox, L"Colormap", 0, y + delta * i++, width, height, terrain->getColormapEnabled());
dialog.AddCheckBox(LightingCheckbox, L"Lighting", 0, y + delta * i++, width, height, terrain->getLightingEnabled());
dialog.AddCheckBox(HeightTextureCheckbox, L"Height-based Texturing", 0, y + delta * i++, width, height, terrain->getHeightTextureEnabled());
dialog.AddCheckBox(SlopeTextureCheckbox, L"Slope-based Texturing", 0, y + delta * i++, width, height, terrain->getSlopeTextureEnabled());
dialog.AddCheckBox(RoughnessCheckbox, L"Enable Roughness", 0, y + delta * i++, width, height, terrain->getRoughnessEnabled());
dialog.AddCheckBox(AntiShimmeringCheckbox, L"Anti Shimmering", 0, y + delta * i++, width, height, terrain->getAntiShimmeringEnabled());
dialog.AddCheckBox(ShowNodesCheckbox, L"Show Nodes", 0, y + delta * i++, width, height, terrain->getShowNodesEnabled());
dialog.AddCheckBox(UniformPatchSizeCheckbox, L"Uniform Patch Size", 0, y + delta * i++, width, height, terrain->getUniformPatchSizeEnabled());
dialog.AddCheckBox(BruteForceCheckbox, L"Brute Force", 0, y + delta * i++, width, height, terrain->getBruteForceEnabled());
dialogResourceManager.OnD3D11CreateDevice(graphicsDevice, deviceContext);
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) );
V_RETURN( g_D3DSettingsDlg.OnD3D11CreateDevice( pd3dDevice ) );
g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 );
// D3DXVECTOR3 vCenter( 0.25767413f, -28.503521f, 111.00689f );
FLOAT fObjectRadius = 378.15607f;
lightpos = D3DXVECTOR3(300,300,-200);
//test = new testing();
hr = test.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = tessplane.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = tesscube.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,80,D3DXVECTOR3(300,50,-200));//D3DXVECTOR3(300,50,-200
hr = lightsphere.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,10,lightpos);
hr = fuse.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = board1.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(300,-300,-1000));
hr = deboard.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(-300,-300,-1000));
hr = geo_alien.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = FirePart.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,80,0); //0 = fire
hr = sky.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(0,0,0));
hr = buildings.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = MissilePart.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,20,1);
g_LightControl.SetRadius( 2000 );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 50.0f, -1000.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f );
g_Camera.SetRotateButtons(true,false,false);
g_Camera.SetViewParams( &vecEye, &vecAt );
g_Camera.SetEnablePositionMovement( true );
g_Camera.SetScalers( 0.005f, 500.0f );
D3D11_DEPTH_STENCIL_DESC descDS;
ZeroMemory(&descDS, sizeof(descDS));
descDS.DepthEnable = false;
descDS.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
descDS.DepthFunc = D3D11_COMPARISON_LESS;
descDS.StencilEnable = FALSE;
hr = pd3dDevice->CreateDepthStencilState( &descDS, &g_DepthState);
//setup stuff for post process
ID3DBlob* pVertexShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"PP1.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) );
ID3DBlob* pPixelShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"PP1.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) );
V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(),
pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPFirstPass ) );
DXUT_SetDebugName( VSPPFirstPass, "VSPost1" );
V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(),
pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPFirstPass ) );
DXUT_SetDebugName( PSPPFirstPass, "PSPost1" );
pVertexShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"Gaussblur.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) );
pPixelShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"Gaussblur.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) );
V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(),
pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPBlur ) );
DXUT_SetDebugName( VSPPBlur, "VSBlur" );
V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(),
pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPBlur ) );
DXUT_SetDebugName( PSPPBlur, "PSBlur" );
pVertexShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"bloom_combine.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) );
pPixelShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"bloom_combine.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) );
V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(),
pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPComb ) );
DXUT_SetDebugName( VSPPComb, "VSComb" );
V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(),
pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPComb ) );
DXUT_SetDebugName( PSPPComb, "PSComb" );
D3D11_BUFFER_DESC Desc;
Desc.Usage = D3D11_USAGE_DYNAMIC;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
Desc.MiscFlags = 0;
Desc.ByteWidth = sizeof( blur_cbuffer );
V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &blur_cb_buffer ) );
DXUT_SetDebugName( blur_cb_buffer, "blur_cb" );
//g_Camera.SetRadius( fObjectRadius * 3.0f, fObjectRadius * 0.5f, fObjectRadius * 10.0f );
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
static bool bFirstOnCreateDevice = true;
// Warn the user that in order to support CS4x, a non-hardware device has been created, continue or quit?
if ( DXUTGetDeviceSettings().d3d11.DriverType != D3D_DRIVER_TYPE_HARDWARE && bFirstOnCreateDevice )
{
if ( MessageBox( 0, L"CS4x capability is missing. "\
L"In order to continue, a non-hardware device has been created, "\
L"it will be very slow, continue?", L"Warning", MB_ICONEXCLAMATION | MB_YESNO ) != IDYES )
return E_FAIL;
}
bFirstOnCreateDevice = false;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) );
V_RETURN( g_D3DSettingsDlg.OnD3D11CreateDevice( pd3dDevice ) );
V_RETURN( g_Tessellator.OnD3D11CreateDevice( pd3dDevice ) );
g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 );
// find the file
WCHAR str[MAX_PATH];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"BaseMesh.obj" ) );
std::wifstream ifs( str );
WCHAR line[256] = {0};
CGrowableArray<D3DXVECTOR4> initdata;
// Parse the .obj file. Both triangle faces and quad faces are supported.
// Only v and f tags are processed, other tags like vn, vt etc are ignored.
{
CGrowableArray<D3DXVECTOR4> v;
while ( ifs >> line )
{
if ( 0 == wcscmp( line, L"#" ) )
ifs.getline( line, 255 );
else
if ( 0 == wcscmp( line, L"v" ) )
{
D3DXVECTOR4 pos;
ifs >> pos.x >> pos.y >> pos.z;
pos.w = 1;
v.Add( pos );
}
}
ifs.clear( 0 );
ifs.seekg( 0 );
while ( ifs >> line )
{
if ( 0 == wcscmp( line, L"#" ) )
ifs.getline( line, 255 );
else
if ( 0 == wcscmp( line, L"f" ) )
{
ifs.getline( line, 255 );
std::wstringstream ss(line);
int idx[4], i = 0;
while ( ss >> line )
{
std::wstringstream ss(line);
ss >> idx[i++];
}
initdata.Add( v[idx[0]-1] ); initdata.Add( v[idx[1]-1] ); initdata.Add( v[idx[2]-1] );
if ( i >= 4 ) // quad face?
{
initdata.Add( v[idx[2]-1] ); initdata.Add( v[idx[3]-1] ); initdata.Add( v[idx[0]-1] );
}
}
}