void Sky::Draw(ID3D11DeviceContext* dc, const Camera& camera)
{
// center Sky about eye in world space
XMFLOAT3 eyePos = camera.GetPosition();
XMMATRIX T = XMMatrixTranslation(eyePos.x, eyePos.y, eyePos.z);
XMMATRIX WVP = XMMatrixMultiply(T, camera.ViewProj());
Effects::SkyFX->SetWorldViewProj(WVP);
Effects::SkyFX->SetCubeMap(mCubeMapSRV);
UINT stride = sizeof(XMFLOAT3);
UINT offset = 0;
dc->IASetVertexBuffers(0, 1, &mVB, &stride, &offset);
dc->IASetIndexBuffer(mIB, DXGI_FORMAT_R16_UINT, 0);
dc->IASetInputLayout(InputLayouts::Pos);
dc->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
D3DX11_TECHNIQUE_DESC techDesc;
Effects::SkyFX->SkyTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
ID3DX11EffectPass* pass = Effects::SkyFX->SkyTech->GetPassByIndex(p);
pass->Apply(0, dc);
dc->DrawIndexed(mIndexCount, 0, 0);
}
}
void D3D11EffectMaterial::ApplyPass(int index)
{
ID3DX11EffectPass* pPass = m_pTech->GetPassByIndex(index);
pPass->Apply(0, m_pContext);
}
void GpuWaves::Disturb(ID3D11DeviceContext* dc, UINT i, UINT j, float magnitude)
{
D3DX11_TECHNIQUE_DESC techDesc;
// The grid element to displace.
Effects::WaveSimFX->SetDisturbIndex(i, j);
// The magnitude of the displacement.
Effects::WaveSimFX->SetDisturbMag(magnitude);
// Displace the current solution heights to generate a wave.
Effects::WaveSimFX->SetCurrSolOutput(mWavesCurrSolUAV);
Effects::WaveSimFX->DisturbWavesTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
ID3DX11EffectPass* pass = Effects::WaveSimFX->DisturbWavesTech->GetPassByIndex(p);
pass->Apply(0, dc);
// One thread group kicks off one thread, which displaces the height of one
// vertex and its neighbors.
dc->Dispatch(1, 1, 1);
}
// Unbind output from compute shader so we can use it as a shader input (a resource cannot be bound
// as an output and input).
ID3D11UnorderedAccessView* nullUAV[1] = { 0 };
dc->CSSetUnorderedAccessViews( 0, 1, nullUAV, 0 );
}
void GaussianMain::ShowImage(ID3D11DeviceContext* pd3dImmediateContext)
{
// Output to default render target
ID3D11RenderTargetView* rtv_array[1] = {g_pRTV_Default};
pd3dImmediateContext->OMSetRenderTargets(1, rtv_array, g_pDSV_Default);
pd3dImmediateContext->RSSetViewports(1, g_VP_Default);
ID3DX11EffectTechnique* pTech = g_pFX_Render->GetTechniqueByName("Tech_ShowImage");
ID3DX11EffectPass* pPass = g_bColorBlur ? pTech->GetPassByName("Pass_ShowColorImage") : pTech->GetPassByName("Pass_ShowMonoImage");
if (g_bColorBlur)
g_pFX_Render->GetVariableByName("g_texColorInput")->AsShaderResource()->SetResource(g_pSRV_Output);
else
g_pFX_Render->GetVariableByName("g_texMonoInput")->AsShaderResource()->SetResource(g_pSRV_Output);
UINT strides = sizeof(SCREEN_VERTEX);
UINT offsets = 0;
ID3D11Buffer* pBuffers[1] = {g_pScreenQuadVB};
pd3dImmediateContext->IASetInputLayout(g_pQuadLayout);
pd3dImmediateContext->IASetVertexBuffers(0, 1, pBuffers, &strides, &offsets);
pd3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
pPass->Apply(0, pd3dImmediateContext);
pd3dImmediateContext->Draw( 4, 0 );
}
void RenderTerrain(ID3D11DeviceContext* pContext, const D3DXMATRIX& mProj, const D3D11_VIEWPORT& vp, const char* passOverride=NULL)
{
SetMatrices(GetApp()->ActiveCam_, mProj);
g_HwTessellation = false;
if (g_HwTessellation)
{
pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST);
pContext->IASetIndexBuffer(g_TileQuadListIB, DXGI_FORMAT_R32_UINT, 0);
}
else
{
pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
pContext->IASetIndexBuffer(g_TileTriStripIB, DXGI_FORMAT_R32_UINT, 0);
}
const char* passName = "ShadedTriStrip";
const bool wire = true;
if (wire)
passName = "Wireframe";
if (g_HwTessellation)
{
if (wire)
passName = "HwTessellatedWireframe";
else
passName = "HwTessellated";
}
if (passOverride != NULL)
passName = passOverride;
ID3DX11EffectPass* pPass = g_pTesselationTechnique->GetPassByName(passName);
if (!pPass)
return; // Shouldn't happen unless the FX file is broken (like wrong pass name).
SetViewport(pContext, vp);
for (int i=0; i!=g_nRings ; ++i)
{
const TileRing* pRing = g_pTileRings[i];
pRing->SetRenderingState(pContext);
g_HeightMapVar->SetResource(g_pHeightMapSRV);
g_GradientMapVar->SetResource(g_pGradientMapSRV);
g_pTileSizeVar->SetFloat(pRing->tileSize());
// Need to apply the pass after setting its vars.
pPass->Apply(0, pContext);
// Instancing is used: one tiles is one instance and the index buffer describes all the
// NxN patches within one tile.
const int nIndices = (g_HwTessellation)? QUAD_LIST_INDEX_COUNT: TRI_STRIP_INDEX_COUNT;
pContext->DrawIndexedInstanced(nIndices, pRing->nTiles(), 0, 0, 0);
}
}
void Terrain::Draw(ID3D11DeviceContext* dc, const Camera& cam, DirectionalLight lights[3])
{
dc->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST);
dc->IASetInputLayout(InputLayouts::Terrain);
UINT stride = sizeof(Vertex::Terrain);
UINT offset = 0;
dc->IASetVertexBuffers(0, 1, &mQuadPatchVB, &stride, &offset);
dc->IASetIndexBuffer(mQuadPatchIB, DXGI_FORMAT_R16_UINT, 0);
XMMATRIX viewProj = cam.ViewProj();
XMMATRIX world = XMLoadFloat4x4(&mWorld);
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);
XMMATRIX worldViewProj = world*viewProj;
XMMATRIX ShadowTransform = world * XMLoadFloat4x4(&d3d->m_ShadowTransform);
XMFLOAT4 worldPlanes[6];
ExtractFrustumPlanes(worldPlanes, viewProj);
// Set per frame constants.
Effects::TerrainFX->SetViewProj(viewProj);
Effects::TerrainFX->SetEyePosW(cam.GetPosition());
Effects::TerrainFX->SetDirLights(lights);
Effects::TerrainFX->SetFogColor(Colors::Silver);
Effects::TerrainFX->SetFogStart(15.0f);
Effects::TerrainFX->SetFogRange(175.0f);
Effects::TerrainFX->SetMinDist(20.0f);
Effects::TerrainFX->SetMaxDist(400.0f);
Effects::TerrainFX->SetMinTess(0.0f);
Effects::TerrainFX->SetMaxTess(6.0f);
Effects::TerrainFX->SetTexelCellSpaceU(1.0f / mInfo.HeightmapWidth);
Effects::TerrainFX->SetTexelCellSpaceV(1.0f / mInfo.HeightmapHeight);
Effects::TerrainFX->SetWorldCellSpace(mInfo.CellSpacing);
Effects::TerrainFX->SetWorldFrustumPlanes(worldPlanes);
Effects::TerrainFX->SetLayerMapArray(mLayerMapArraySRV);
Effects::TerrainFX->SetBlendMap(mBlendMapSRV);
Effects::TerrainFX->SetHeightMap(mHeightMapSRV);
Effects::TerrainFX->SetShadowMap(d3d->GetShadowMap());
Effects::TerrainFX->SetShadowTransform(ShadowTransform);
Effects::TerrainFX->SetMaterial(mMat);
ID3DX11EffectTechnique* tech = Effects::TerrainFX->Light1Tech;
D3DX11_TECHNIQUE_DESC techDesc;
tech->GetDesc( &techDesc );
for(UINT i = 0; i < techDesc.Passes; ++i)
{
ID3DX11EffectPass* pass = tech->GetPassByIndex(i);
pass->Apply(0, dc);
dc->DrawIndexed(mNumPatchQuadFaces*4, 0, 0);
}
dc->HSSetShader(0, 0, 0);
dc->DSSetShader(0, 0, 0);
}
void EffectSystemD3D11::ApplyEffect(int effectID, const char *techName, const char *passName)
{
ASSERT_EFFECT(effectID);
ID3DX11EffectPass *pass = nullptr;
pass = mEffects[effectID]->GetTechniqueByName(techName)->GetPassByName(passName);
if (pass->IsValid())
{
pass->Apply(0, mContext);
}
}
HRESULT Shader::Apply( unsigned int pass )
{
ID3DX11EffectPass* p = this->zTechnique->GetPassByIndex(pass);
if (p)
{
p->Apply(0, this->zDeviceContext);
if (this->zInputLayout)
{
this->zDeviceContext->IASetInputLayout(this->zInputLayout);
}
return S_OK;
}
return E_FAIL;
}
HRESULT Shader::Apply(unsigned int pass)
{
ID3DX11EffectPass* p = m_pTechnique->GetPassByIndex(pass);
if(p)
{
p->Apply(0, mDevice3D->GetDeviceContext());
if(m_pInputLayout)
{
mDevice3D->GetDeviceContext()->IASetInputLayout(m_pInputLayout);
}
return S_OK;
}
return E_FAIL;
}
void RawDataViewer::ShowRawVoxeldata(ID3D11ShaderResourceView* pData, float fIndex)
{
// Find a slice by an index, and then render it on a full-screen quad.
mDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
mTargetVar->SetResource(pData);
mIndexVar->SetFloat(fIndex);
mDeviceContext->IASetInputLayout(mVertexSlipLayout);
UINT stride = sizeof(VertexSlip);
UINT offset = 0;
mDeviceContext->IASetVertexBuffers(0, 1, &mVB, &stride, &offset);
ID3DX11EffectPass* pass = mRttTech->GetPassByIndex(0);
pass->Apply(0, mDeviceContext);
mDeviceContext->Draw(6, 0);
}
void DX11SpriteBatch::EndBatch(ID3D11DeviceContext* dc)
{
assert(mInitialized);
u32 viewportCount = 1;
D3D11_VIEWPORT vp;
dc->RSGetViewports(&viewportCount, &vp);
mScreenWidth = vp.Width;
mScreenHeight = vp.Height;
u32 stride = sizeof(MeshData::SpriteVertex);
u32 offset = 0;
dc->IASetInputLayout(mInputLayout);
dc->IASetIndexBuffer(mIndexBuffer, DXGI_FORMAT_R16_UINT, 0);
dc->IASetVertexBuffers(0, 1, &mVertexBuffer, &stride, &offset);
dc->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
DX11Effects::SpriteFX->SetSpriteMap(mBatchTexSRV);
ID3DX11EffectPass* pass = DX11Effects::SpriteFX->SpriteTech->GetPassByIndex(0);
pass->Apply(0, dc);
u32 spritesToDraw = (u32)mSpriteList.size();
u32 startIndex = 0;
while( spritesToDraw > 0 )
{
if( spritesToDraw <= BatchSize )
{
DrawBatch(dc, startIndex, spritesToDraw);
spritesToDraw = 0;
}
else
{
DrawBatch(dc, startIndex, BatchSize);
startIndex += BatchSize;
spritesToDraw -= BatchSize;
}
}
RJE_SAFE_RELEASE(mBatchTexSRV);
}
void h2GBufferDebugDraw::RenderGBuffer() {
m_Renderer->m_D3d11ImmediateContext->ClearDepthStencilView( m_Renderer->m_DepthBufferDSV, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0 );
m_Renderer->m_D3d11ImmediateContext->IASetInputLayout( m_PosTexLayout );
m_Renderer->m_D3d11ImmediateContext->OMSetRenderTargets( 1, &m_Renderer->m_BackbufferRTV, m_Renderer->m_DepthBufferDSV );
ID3DX11EffectShaderResourceVariable * fxTexSamplerVar;
fxTexSamplerVar = m_Fx->GetVariableByName( "texSampler" )->AsShaderResource();
fxTexSamplerVar->SetResource( m_Renderer->m_GBuffer->GetBufferByType( m_CurrentBuffer )->m_SRV );
unsigned int stride = sizeof( h2RenderingEngine::vertexPosTex_t );
unsigned int offset = 0;
m_Renderer->m_D3d11ImmediateContext->IASetVertexBuffers( 0, 1, &m_Renderer->m_FullScrQuadVB, &stride, &offset );
const h2SceneObject * cameraObj = h2Engine::GetScene()->GetMainCamera();
const h2Camera * camera = static_cast<h2Camera *>( cameraObj->GetComponent( "h2Camera" ) );
h2Matrix44 projMatrix = h2Matrix44::OrthographicD3D( m_Renderer->m_Width, m_Renderer->m_Height, camera->zNear, camera->zFar );
ID3DX11EffectMatrixVariable * fxPVar = m_Fx->GetVariableByName( "orthoProjection" )->AsMatrix();
fxPVar->SetMatrix( projMatrix.GetDataPtr() );
ID3DX11EffectTechnique * tech = nullptr;
switch ( m_CurrentBuffer ) {
case DEPTH_BUFFER:
tech = m_Fx->GetTechniqueByName( "DepthBufferDebugDrawTech" );
break;
case NORMAL_BUFFER:
tech = m_Fx->GetTechniqueByName( "NormalBufferDebugDrawTech" );
break;
}
ID3DX11EffectPass * pass = tech->GetPassByIndex( 0 );
pass->Apply( 0, m_Renderer->m_D3d11ImmediateContext );
m_Renderer->m_D3d11ImmediateContext->Draw( 6, 0 );
ID3D11ShaderResourceView * emptySRV = nullptr;
m_Renderer->m_D3d11ImmediateContext->PSSetShaderResources(0, 1, &emptySRV);
}
void Entity::DrawShadow(ID3DX11EffectTechnique* activeTech, ID3D11DeviceContext* context, const Camera& camera, XMFLOAT4X4 lightView, XMFLOAT4X4 lightProj)
{
XMMATRIX view = XMLoadFloat4x4(&lightView);
XMMATRIX proj = XMLoadFloat4x4(&lightProj);
XMMATRIX viewProj = XMMatrixMultiply(view, proj);
ID3DX11EffectTechnique* smapTech = Effects::BuildShadowMapFX->BuildShadowMapAlphaClipTech;
D3DX11_TECHNIQUE_DESC techDesc;
smapTech->GetDesc(&techDesc);
for (UINT p = 0; p < techDesc.Passes; ++p)
{
ID3DX11EffectPass* pass = activeTech->GetPassByIndex(p);
XMMATRIX world = XMLoadFloat4x4(&mWorld);
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);
XMMATRIX worldViewProj = world*view*proj;
Effects::BuildShadowMapFX->SetWorld(world);
Effects::BuildShadowMapFX->SetWorldInvTranspose(worldInvTranspose);
Effects::BuildShadowMapFX->SetWorldViewProj(worldViewProj);
Effects::BuildShadowMapFX->SetDiffuseMap(mTexSRV);
if (!useTexTrans){ Effects::BuildShadowMapFX->SetTexTransform(XMMatrixScaling(origTexScale.x, origTexScale.y, origTexScale.z)); }
if (mBasicTexTrans)
{
Effects::BuildShadowMapFX->SetTexTransform(XMMatrixTranslation(texTrans.x, texTrans.y, texTrans.z)*XMMatrixScaling(origTexScale.x, origTexScale.y, origTexScale.z));
}
if (mUseAnimation)
{
XMMATRIX Scale;
mAnim->Flipped() ? Scale = XMMatrixScaling(-origTexScale.x, origTexScale.y, origTexScale.z) : Scale = XMMatrixScaling(origTexScale.x, origTexScale.y, origTexScale.z);
Effects::BuildShadowMapFX->SetTexTransform(XMMatrixTranslation(mAnim->GetX(), mAnim->GetY(), texTrans.z)*Scale);
}
pass->Apply(0, context);
context->DrawIndexed(mIndexCount, mIndexOffset, mVertexOffset);
}
}
void GpuWaves::Update(ID3D11DeviceContext* dc, float dt)
{
static float t = 0;
// Accumulate time.
t += dt;
// Only update the simulation at the specified time step.
if( t >= mTimeStep )
{
D3DX11_TECHNIQUE_DESC techDesc;
Effects::WaveSimFX->SetWaveConstants(mK);
Effects::WaveSimFX->SetPrevSolInput(mWavesPrevSolSRV);
Effects::WaveSimFX->SetCurrSolInput(mWavesCurrSolSRV);
Effects::WaveSimFX->SetNextSolOutput(mWavesNextSolUAV);
Effects::WaveSimFX->UpdateWavesTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
ID3DX11EffectPass* pass = Effects::WaveSimFX->UpdateWavesTech->GetPassByIndex(p);
pass->Apply(0, dc);
// How many groups do we need to dispatch to cover the wave grid.
// Note that mNumRows and mNumCols should be divisible by 16
// so there is no remainder.
UINT numGroupsX = mNumCols / 16;
UINT numGroupsY = mNumRows / 16;
dc->Dispatch(numGroupsX, numGroupsY, 1);
}
// Unbind the input textures from the CS for good housekeeping.
ID3D11ShaderResourceView* nullSRV[1] = { 0 };
dc->CSSetShaderResources( 0, 1, nullSRV );
// Unbind output from compute shader (we are going to use this output as an input in the next pass,
// and a resource cannot be both an output and input at the same time.
ID3D11UnorderedAccessView* nullUAV[1] = { 0 };
dc->CSSetUnorderedAccessViews( 0, 1, nullUAV, 0 );
// Disable compute shader.
dc->CSSetShader(0, 0, 0);
//
// Ping-pong buffers in preparation for the next update.
// The previous solution is no longer needed and becomes the target of the next solution in the next update.
// The current solution becomes the previous solution.
// The next solution becomes the current solution.
//
ID3D11ShaderResourceView* srvTemp = mWavesPrevSolSRV;
mWavesPrevSolSRV = mWavesCurrSolSRV;
mWavesCurrSolSRV = mWavesNextSolSRV;
mWavesNextSolSRV = srvTemp;
ID3D11UnorderedAccessView* uavTemp = mWavesPrevSolUAV;
mWavesPrevSolUAV = mWavesCurrSolUAV;
mWavesCurrSolUAV = mWavesNextSolUAV;
mWavesNextSolUAV = uavTemp;
t = 0.0f; // reset time
}
}
void EndOfDirectX11::Render()
{
if( d3dContext_ == 0 )
{
return;
}
float clearColor[] = { 0.0f, 0.0f, 0.25f, 1.0f };
d3dContext_->ClearRenderTargetView( backBufferTarget_, clearColor );
d3dContext_->ClearDepthStencilView( depthStencilView_, D3D11_CLEAR_DEPTH, 1.0f, 0 );
unsigned int stride = sizeof( VertexPos );
unsigned int offset = 0;
d3dContext_->IASetInputLayout( inputLayout_ );
d3dContext_->IASetVertexBuffers( 0, 1, &vertexBuffer_, &stride, &offset );
d3dContext_->IASetIndexBuffer( indexBuffer_, DXGI_FORMAT_R16_UINT, 0 );
d3dContext_->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
ID3DX11EffectShaderResourceVariable * colorMap = 0;
colorMap = effect_->GetVariableByName( "colorMap" )->AsShaderResource();
colorMap->SetResource( colorMap_ );
ID3DX11EffectShaderResourceVariable* colorMap2;
colorMap2 = effect_->GetVariableByName( "secondMap" )->AsShaderResource( );
colorMap2->SetResource( secondMap_ );
ID3DX11EffectSamplerVariable * samplerState = 0;
samplerState = effect_->GetVariableByName( "colorSampler" )->AsSampler();
samplerState->SetSampler( 0, samplerState_ );
ID3DX11EffectMatrixVariable * worldMatrix = 0;
worldMatrix = effect_->GetVariableByName( "worldMatrix" )->AsMatrix();
worldMatrix->SetMatrix( ( float * )&worldMat_ );
ID3DX11EffectMatrixVariable * viewMatrix = 0;
viewMatrix = effect_->GetVariableByName( "viewMatrix" )->AsMatrix();
viewMatrix->SetMatrix( ( float * )&viewMatrix_ );
ID3DX11EffectMatrixVariable * projMatrix = 0;
projMatrix = effect_->GetVariableByName( "projMatrix" )->AsMatrix();
projMatrix->SetMatrix( ( float * )&projMatrix_ );
ID3DX11EffectTechnique * colorInvTechnique = 0;
colorInvTechnique = effect_->GetTechniqueByName( "MultiTexture" );
D3DX11_TECHNIQUE_DESC techDesc;
colorInvTechnique->GetDesc( &techDesc );
for( unsigned int p = 0; p < techDesc.Passes; ++p )
{
ID3DX11EffectPass * pass = colorInvTechnique->GetPassByIndex( p );
if( pass != 0 )
{
pass->Apply( 0, d3dContext_ );
d3dContext_->DrawIndexed( 36, 0, 0 );
}
}
swapChain_->Present( 0, 0 );
}
void App::drawScene( void )
{
mD3DImmediateContext->ClearRenderTargetView( mRenderTargetView,
reinterpret_cast<const float*>( &Colors::Black ) );
mD3DImmediateContext->ClearDepthStencilView( mDepthStencilView,
D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL,
1.f,
0 );
mD3DImmediateContext->IASetInputLayout( InputLayouts::Basic32 );
mD3DImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
float blendFactor [] = { 0.f, 0.f, 0.f, 0.f };
const UINT stride = sizeof( Vertex::Basic32 );
const UINT offset = 0;
XMMATRIX view = XMLoadFloat4x4( &mView );
XMMATRIX proj = XMLoadFloat4x4( &mProj );
const XMMATRIX viewProj = view * proj;
// Set per-frame constants.
Effects::BasicFX->SetDirLights( mDirLights );
Effects::BasicFX->SetEyePosW( mEyePosW );
Effects::BasicFX->SetFogColor( Colors::Black );
Effects::BasicFX->SetFogStart( 2.f );
Effects::BasicFX->SetFogRange( 40.f );
ID3DX11EffectTechnique* tech = Effects::BasicFX->Light0TexTech;
ID3DX11EffectTechnique* activeSkullTech = Effects::BasicFX->Light0TexTech;
switch ( mRenderOptions )
{
case RenderOptions::Lighting:
tech = Effects::BasicFX->Light3Tech;
activeSkullTech = Effects::BasicFX->Light3Tech;
break;
case RenderOptions::Textures:
tech = Effects::BasicFX->Light3TexTech;
activeSkullTech = Effects::BasicFX->Light3Tech;
break;
case RenderOptions::TexturesAndFog:
tech = Effects::BasicFX->Light3TexFogTech;
activeSkullTech = Effects::BasicFX->Light3FogTech;
break;
}
D3DX11_TECHNIQUE_DESC techDesc;
//
// Draw floor and walls to back buffer as normal.
tech->GetDesc( &techDesc );
for ( UINT p = 0; p < techDesc.Passes; ++p ) {
ID3DX11EffectPass* pass = tech->GetPassByIndex( p );
mD3DImmediateContext->IASetVertexBuffers( 0, 1, &mRoomVB, &stride, &offset );
// ???
// Set per-object constants.
XMMATRIX world = XMLoadFloat4x4( &mRoomWorld );
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose( world );
XMMATRIX worldViewProj = world * viewProj;
Effects::BasicFX->SetWorld( world );
Effects::BasicFX->SetWorldInvTranspose( worldInvTranspose );
Effects::BasicFX->SetWorldViewProj( worldViewProj );
Effects::BasicFX->SetTexTransform( XMMatrixIdentity() );
Effects::BasicFX->SetMaterial( mRoomMat );
// Floor.
Effects::BasicFX->SetDiffuseMap( mFloorDiffuseMapSRV );
pass->Apply( 0, mD3DImmediateContext );
mD3DImmediateContext->Draw( 6, 0 );
// Wall.
Effects::BasicFX->SetDiffuseMap( mWallDiffuseMapSRV );
pass->Apply( 0, mD3DImmediateContext );
mD3DImmediateContext->Draw( 18, 6 );
}
//
// Draw the skull to the back buffer as normal.
activeSkullTech->GetDesc( &techDesc );
for ( UINT p = 0; p < techDesc.Passes; ++p ) {
ID3DX11EffectPass* pass = activeSkullTech->GetPassByIndex( p );
mD3DImmediateContext->IASetVertexBuffers( 0, 1, &mSkullVB, &stride, &offset );
mD3DImmediateContext->IASetIndexBuffer( mSkullIB, DXGI_FORMAT_R32_UINT, 0 );
XMMATRIX world = XMLoadFloat4x4( &mSkullWorld );
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose( world );
XMMATRIX worldViewProj = world*view*proj;
Effects::BasicFX->SetWorld( world );
Effects::BasicFX->SetWorldInvTranspose( worldInvTranspose );
Effects::BasicFX->SetWorldViewProj( worldViewProj );
Effects::BasicFX->SetMaterial( mSkullMat );
pass->Apply( 0, mD3DImmediateContext );
mD3DImmediateContext->DrawIndexed( mSkullIndexCount, 0, 0 );
}
//
// Draw the mirror into the stencil buffer only.
tech->GetDesc( &techDesc );
for ( UINT p = 0; p < techDesc.Passes; ++p ) {
ID3DX11EffectPass* pass = tech->GetPassByIndex( 0 );
mD3DImmediateContext->IASetVertexBuffers( 0, 1, &mRoomVB, &stride, &offset );
// Set per object constants.
XMMATRIX world = XMLoadFloat4x4( &mRoomWorld );
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose( world );
XMMATRIX worldViewProj = world*view*proj;
Effects::BasicFX->SetWorld( world );
Effects::BasicFX->SetWorldInvTranspose( worldInvTranspose );
Effects::BasicFX->SetWorldViewProj( worldViewProj );
Effects::BasicFX->SetTexTransform( XMMatrixIdentity() );
// Do not write to render target.
mD3DImmediateContext->OMSetBlendState( RenderStates::NoRenderTargetWritesBS,
blendFactor,
0xffffffff );
// Render visible mirror pixels to stencil buffer.
// Do not write mirror depth to depth buffer to avoid occluding the reflection.
mD3DImmediateContext->OMSetDepthStencilState( RenderStates::MarkMirrorDSS,
1 );
pass->Apply( 0, mD3DImmediateContext );
mD3DImmediateContext->Draw( 6, 24 );
// Restore states.
mD3DImmediateContext->OMSetBlendState( nullptr, blendFactor, 0xffffffff );
mD3DImmediateContext->OMSetDepthStencilState( nullptr, 0 );
}
//
// Draw skull reflection to back buffer.
activeSkullTech->GetDesc( &techDesc );
for ( UINT p = 0; p < techDesc.Passes; ++p ) {
ID3DX11EffectPass* pass = activeSkullTech->GetPassByIndex( p );
mD3DImmediateContext->IASetVertexBuffers( 0, 1, &mSkullVB, &stride, &offset );
mD3DImmediateContext->IASetIndexBuffer( mSkullIB, DXGI_FORMAT_R32_UINT, 0 );
XMVECTOR mirrorPlane = XMVectorSet( 0.0f, 0.0f, 1.0f, 0.0f ); // xy plane
XMMATRIX R = XMMatrixReflect( mirrorPlane );
//XMMATRIX world = XMMatrixRotationY( MathHelper::Pi ) * XMLoadFloat4x4( &mSkullWorld ) * R;
XMMATRIX world = XMLoadFloat4x4( &mSkullWorld ) * R;
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose( world );
XMMATRIX worldViewProj = world*view*proj;
Effects::BasicFX->SetWorld( world );
Effects::BasicFX->SetWorldInvTranspose( worldInvTranspose );
Effects::BasicFX->SetWorldViewProj( worldViewProj );
Effects::BasicFX->SetMaterial( mSkullMat );
// Cache old light directions, then reflect them.
XMFLOAT3 oldLightDirs[3];
for ( int i = 0; i < 3; ++i ) {
oldLightDirs[i] = mDirLights[i].direction;
XMVECTOR dir = XMLoadFloat3( &mDirLights[i].direction );
XMVECTOR reflection = XMVector3TransformNormal( dir, R );
XMStoreFloat3( &mDirLights[i].direction, reflection );
}
Effects::BasicFX->SetDirLights( mDirLights );
// Cull clockwise triangles for reflection.
mD3DImmediateContext->RSSetState( RenderStates::CullClockwiseRS );
// Only draw reflection into visible mirror pixels as marked by stencil buffer.
mD3DImmediateContext->OMSetDepthStencilState( RenderStates::DrawReflectionDSS,
1 );
pass->Apply( 0, mD3DImmediateContext );
mD3DImmediateContext->DrawIndexed( mSkullIndexCount, 0, 0 );
// Restore default states.
mD3DImmediateContext->RSSetState( nullptr );
mD3DImmediateContext->OMSetDepthStencilState( nullptr, 0 );
// Restore light directions.
for ( int i = 0; i < 3; ++i )
{
mDirLights[i].direction = oldLightDirs[i];
}
Effects::BasicFX->SetDirLights( mDirLights );
}
// Draw mirror to back buffer.
tech->GetDesc( &techDesc );
for ( UINT p = 0; p < techDesc.Passes; ++p )
{
ID3DX11EffectPass* pass = tech->GetPassByIndex( p );
mD3DImmediateContext->IASetVertexBuffers( 0, 1, &mRoomVB, &stride, &offset );
// Set per object constants.
XMMATRIX world = XMLoadFloat4x4( &mRoomWorld );
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose( world );
XMMATRIX worldViewProj = world*view*proj;
Effects::BasicFX->SetWorld( world );
Effects::BasicFX->SetWorldInvTranspose( worldInvTranspose );
Effects::BasicFX->SetWorldViewProj( worldViewProj );
Effects::BasicFX->SetTexTransform( XMMatrixIdentity() );
Effects::BasicFX->SetMaterial( mMirrorMat );
Effects::BasicFX->SetDiffuseMap( mMirrorDiffuseMapSRV );
// Mirror
mD3DImmediateContext->OMSetBlendState( RenderStates::TransparentBS, blendFactor, 0xffffffff );
pass->Apply( 0, mD3DImmediateContext );
mD3DImmediateContext->Draw( 6, 24 );
}
// Draw skull shadow.
activeSkullTech->GetDesc( &techDesc );
for ( UINT p = 0; p < techDesc.Passes; ++p ) {
ID3DX11EffectPass* pass = activeSkullTech->GetPassByIndex( p );
mD3DImmediateContext->IASetVertexBuffers( 0, 1, &mSkullVB, &stride, &offset );
mD3DImmediateContext->IASetIndexBuffer( mSkullIB, DXGI_FORMAT_R32_UINT, 0 );
XMVECTOR shadowPlane = XMVectorSet( 0.f, 1.f, 0.f, 0.f );
XMVECTOR toMainLight = -XMLoadFloat3( &mDirLights[0].direction );
XMMATRIX S = XMMatrixShadow( shadowPlane, toMainLight );
XMMATRIX shadowOffsetY = XMMatrixTranslation( 0.f, 0.001f, 0.f );
// Set per-object constants.
XMMATRIX world = XMLoadFloat4x4( &mSkullWorld ) * S * shadowOffsetY;
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose( world );
XMMATRIX worldViewProj = world*view*proj;
Effects::BasicFX->SetWorld( world );
Effects::BasicFX->SetWorldInvTranspose( worldInvTranspose );
Effects::BasicFX->SetWorldViewProj( worldViewProj );
Effects::BasicFX->SetMaterial( mShadowMat );
mD3DImmediateContext->OMSetDepthStencilState( RenderStates::NoDoubleBlendDSS,
0 );
pass->Apply( 0, mD3DImmediateContext );
mD3DImmediateContext->DrawIndexed( mSkullIndexCount, 0, 0 );
// Restore default states.
mD3DImmediateContext->OMSetBlendState( 0, blendFactor, 0xffffffff );
mD3DImmediateContext->OMSetDepthStencilState( 0, 0 );
}
HR( mSwapChain->Present( 0, 0 ) );
}
void GaussianMain::ApplyGaussianFilter(ID3D11DeviceContext* pd3dImmediateContext)
{
D3D11_TEXTURE2D_DESC tex_desc;
g_pTex_Scene->GetDesc(&tex_desc);
float box_width = CalculateBoxFilterWidth(g_FilterRadius, g_NumApproxPasses);
float half_box_width = box_width * 0.5f;
float frac_half_box_width = (half_box_width + 0.5f) - (int)(half_box_width + 0.5f);
float inv_frac_half_box_width = 1.0f - frac_half_box_width;
float rcp_box_width = 1.0f / box_width;
// Step 1. Vertical passes: Each thread group handles a colomn in the image
ID3DX11EffectTechnique* pTech = g_pFX_GaussianCol->GetTechniqueByName("Tech_GaussianFilter");
// Input texture
g_pFX_GaussianCol->GetVariableByName("g_texInput")->AsShaderResource()->SetResource(g_pSRV_Scene);
// Output texture
g_pFX_GaussianCol->GetVariableByName("g_rwtOutput")->AsUnorderedAccessView()->SetUnorderedAccessView(g_pUAV_Output);
g_pFX_GaussianCol->GetVariableByName("g_NumApproxPasses")->AsScalar()->SetInt(g_NumApproxPasses - 1);
g_pFX_GaussianCol->GetVariableByName("g_HalfBoxFilterWidth")->AsScalar()->SetFloat(half_box_width);
g_pFX_GaussianCol->GetVariableByName("g_FracHalfBoxFilterWidth")->AsScalar()->SetFloat(frac_half_box_width);
g_pFX_GaussianCol->GetVariableByName("g_InvFracHalfBoxFilterWidth")->AsScalar()->SetFloat(inv_frac_half_box_width);
g_pFX_GaussianCol->GetVariableByName("g_RcpBoxFilterWidth")->AsScalar()->SetFloat(rcp_box_width);
// Select pass
ID3DX11EffectPass* pPass = g_bColorBlur ? pTech->GetPassByName("Pass_GaussianColor") : pTech->GetPassByName("Pass_GaussianMono");
pPass->Apply(0, pd3dImmediateContext);
pd3dImmediateContext->Dispatch(tex_desc.Width, 1, 1);
// Unbound CS resource and output
ID3D11ShaderResourceView* srv_array[] = {NULL, NULL, NULL, NULL};
pd3dImmediateContext->CSSetShaderResources(0, 4, srv_array);
ID3D11UnorderedAccessView* uav_array[] = {NULL, NULL, NULL, NULL};
pd3dImmediateContext->CSSetUnorderedAccessViews(0, 4, uav_array, NULL);
// Step 2. Horizontal passes: Each thread group handles a row in the image
pTech = g_pFX_GaussianRow->GetTechniqueByName("Tech_GaussianFilter");
// Input texture
g_pFX_GaussianRow->GetVariableByName("g_texInput")->AsShaderResource()->SetResource(g_pSRV_Scene);
// Output texture
g_pFX_GaussianRow->GetVariableByName("g_rwtOutput")->AsUnorderedAccessView()->SetUnorderedAccessView(g_pUAV_Output);
g_pFX_GaussianRow->GetVariableByName("g_NumApproxPasses")->AsScalar()->SetInt(g_NumApproxPasses - 1);
g_pFX_GaussianRow->GetVariableByName("g_HalfBoxFilterWidth")->AsScalar()->SetFloat(half_box_width);
g_pFX_GaussianRow->GetVariableByName("g_FracHalfBoxFilterWidth")->AsScalar()->SetFloat(frac_half_box_width);
g_pFX_GaussianRow->GetVariableByName("g_InvFracHalfBoxFilterWidth")->AsScalar()->SetFloat(inv_frac_half_box_width);
g_pFX_GaussianRow->GetVariableByName("g_RcpBoxFilterWidth")->AsScalar()->SetFloat(rcp_box_width);
// Select pass
pPass = g_bColorBlur ? pTech->GetPassByName("Pass_GaussianColor") : pTech->GetPassByName("Pass_GaussianMono");
pPass->Apply(0, pd3dImmediateContext);
pd3dImmediateContext->Dispatch(tex_desc.Height, 1, 1);
// Unbound CS resource and output
pd3dImmediateContext->CSSetShaderResources(0, 4, srv_array);
pd3dImmediateContext->CSSetUnorderedAccessViews(0, 4, uav_array, NULL);
}