ID3D11DepthStencilState* StateCache::Get(ZMode state)
{
auto it = m_depth.find(state.hex);
if (it != m_depth.end())
return it->second;
D3D11_DEPTH_STENCIL_DESC depthdc = CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT());
depthdc.DepthEnable = TRUE;
depthdc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthdc.DepthFunc = D3D11_COMPARISON_LESS;
depthdc.StencilEnable = FALSE;
depthdc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
depthdc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
const D3D11_COMPARISON_FUNC d3dCmpFuncs[8] =
{
D3D11_COMPARISON_NEVER,
D3D11_COMPARISON_LESS,
D3D11_COMPARISON_EQUAL,
D3D11_COMPARISON_LESS_EQUAL,
D3D11_COMPARISON_GREATER,
D3D11_COMPARISON_NOT_EQUAL,
D3D11_COMPARISON_GREATER_EQUAL,
D3D11_COMPARISON_ALWAYS
};
if (state.testenable)
{
depthdc.DepthEnable = TRUE;
depthdc.DepthWriteMask = state.updateenable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO;
depthdc.DepthFunc = d3dCmpFuncs[state.func];
}
else
{
// if the test is disabled write is disabled too
depthdc.DepthEnable = FALSE;
depthdc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
}
ID3D11DepthStencilState* res = nullptr;
HRESULT hr = D3D::device->CreateDepthStencilState(&depthdc, &res);
if (SUCCEEDED(hr)) D3D::SetDebugObjectName((ID3D11DeviceChild*)res, "depth-stencil state used to emulate the GX pipeline");
else PanicAlert("Failed to create depth state at %s %d\n", __FILE__, __LINE__);
m_depth.insert(std::make_pair(state.hex, res));
return res;
}
void TextComponent::DrawTextUI(){
if (!impl->mModel){
impl->mModel = gameObject->GetComponent<TextureModelComponent>();
}
Game::AddDrawList(DrawStage::UI, [&](){
if (!impl->mModel)return;
impl->mModel->SetMatrix();
Model& model = *impl->mModel->mModel;
ID3D11DepthStencilState* pBackDS;
UINT ref;
Device::mpImmediateContext->OMGetDepthStencilState(&pBackDS, &ref);
D3D11_DEPTH_STENCIL_DESC descDS = CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT());
descDS.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
//descDS.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
descDS.DepthFunc = D3D11_COMPARISON_ALWAYS;
ID3D11DepthStencilState* pDS_tex = NULL;
Device::mpd3dDevice->CreateDepthStencilState(&descDS, &pDS_tex);
Device::mpImmediateContext->OMSetDepthStencilState(pDS_tex, 0);
D3D11_RASTERIZER_DESC descRS = CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT());
descRS.CullMode = D3D11_CULL_BACK;
descRS.FillMode = D3D11_FILL_SOLID;
ID3D11RasterizerState* pRS = NULL;
Device::mpd3dDevice->CreateRasterizerState(&descRS, &pRS);
Device::mpImmediateContext->RSSetState(pRS);
model.Draw(impl->mTexMaterial);
Device::mpImmediateContext->RSSetState(NULL);
if (pRS)pRS->Release();
Device::mpImmediateContext->OMSetDepthStencilState(NULL, 0);
pDS_tex->Release();
Device::mpImmediateContext->OMSetDepthStencilState(pBackDS, ref);
if (pBackDS)pBackDS->Release();
});
}
void DeferredRendering::Debug_AlbedoOnly_Rendering(RenderTarget* rt){
Model::mForcedMaterialUseTexture = NULL;
rt->SetRendererTarget();
mModelTexture.Update();
ID3D11DepthStencilState* pBackDS;
UINT ref;
Device::mpImmediateContext->OMGetDepthStencilState(&pBackDS, &ref);
D3D11_DEPTH_STENCIL_DESC descDS = CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT());
descDS.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
descDS.DepthFunc = D3D11_COMPARISON_ALWAYS;
ID3D11DepthStencilState* pDS_tex = NULL;
Device::mpd3dDevice->CreateDepthStencilState(&descDS, &pDS_tex);
Device::mpImmediateContext->OMSetDepthStencilState(pDS_tex, 0);
D3D11_RASTERIZER_DESC descRS = CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT());
descRS.CullMode = D3D11_CULL_NONE;
descRS.FillMode = D3D11_FILL_SOLID;
ID3D11RasterizerState* pRS = NULL;
Device::mpd3dDevice->CreateRasterizerState(&descRS, &pRS);
Device::mpImmediateContext->RSSetState(pRS);
mModelTexture.Draw(mMaterialDebugDraw);
Device::mpImmediateContext->RSSetState(NULL);
if (pRS)pRS->Release();
Device::mpImmediateContext->OMSetDepthStencilState(NULL, 0);
pDS_tex->Release();
Device::mpImmediateContext->OMSetDepthStencilState(pBackDS, ref);
if (pBackDS)pBackDS->Release();
RenderTarget::NullSetRendererTarget();
mMaterialPostEffect.PSSetShaderResources();
}
void XFBEncoder::Init()
{
HRESULT hr;
// Create output texture
// The pixel shader can generate one YUYV entry per pixel. One YUYV entry
// is created for every two EFB pixels.
D3D11_TEXTURE2D_DESC t2dd = CD3D11_TEXTURE2D_DESC(
DXGI_FORMAT_R8G8B8A8_UNORM, MAX_XFB_WIDTH/2, MAX_XFB_HEIGHT, 1, 1,
D3D11_BIND_RENDER_TARGET);
hr = D3D::device->CreateTexture2D(&t2dd, nullptr, &m_out);
CHECK(SUCCEEDED(hr), "create xfb encoder output texture");
D3D::SetDebugObjectName(m_out, "xfb encoder output texture");
// Create output render target view
D3D11_RENDER_TARGET_VIEW_DESC rtvd = CD3D11_RENDER_TARGET_VIEW_DESC(m_out,
D3D11_RTV_DIMENSION_TEXTURE2D, DXGI_FORMAT_R8G8B8A8_UNORM);
hr = D3D::device->CreateRenderTargetView(m_out, &rtvd, &m_outRTV);
CHECK(SUCCEEDED(hr), "create xfb encoder output texture rtv");
D3D::SetDebugObjectName(m_outRTV, "xfb encoder output rtv");
// Create output staging buffer
t2dd.Usage = D3D11_USAGE_STAGING;
t2dd.BindFlags = 0;
t2dd.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
hr = D3D::device->CreateTexture2D(&t2dd, nullptr, &m_outStage);
CHECK(SUCCEEDED(hr), "create xfb encoder output staging buffer");
D3D::SetDebugObjectName(m_outStage, "xfb encoder output staging buffer");
// Create constant buffer for uploading params to shaders
D3D11_BUFFER_DESC bd = CD3D11_BUFFER_DESC(sizeof(XFBEncodeParams),
D3D11_BIND_CONSTANT_BUFFER);
hr = D3D::device->CreateBuffer(&bd, nullptr, &m_encodeParams);
CHECK(SUCCEEDED(hr), "create xfb encode params buffer");
D3D::SetDebugObjectName(m_encodeParams, "xfb encoder params buffer");
// Create vertex quad
bd = CD3D11_BUFFER_DESC(sizeof(QUAD_VERTS), D3D11_BIND_VERTEX_BUFFER,
D3D11_USAGE_IMMUTABLE);
D3D11_SUBRESOURCE_DATA srd = { QUAD_VERTS, 0, 0 };
hr = D3D::device->CreateBuffer(&bd, &srd, &m_quad);
CHECK(SUCCEEDED(hr), "create xfb encode quad vertex buffer");
D3D::SetDebugObjectName(m_quad, "xfb encoder quad vertex buffer");
// Create vertex shader
D3DBlob* bytecode = nullptr;
if (!D3D::CompileVertexShader(XFB_ENCODE_VS, &bytecode))
{
ERROR_LOG(VIDEO, "XFB encode vertex shader failed to compile");
return;
}
hr = D3D::device->CreateVertexShader(bytecode->Data(), bytecode->Size(), nullptr, &m_vShader);
CHECK(SUCCEEDED(hr), "create xfb encode vertex shader");
D3D::SetDebugObjectName(m_vShader, "xfb encoder vertex shader");
// Create input layout for vertex quad using bytecode from vertex shader
hr = D3D::device->CreateInputLayout(QUAD_LAYOUT_DESC,
sizeof(QUAD_LAYOUT_DESC)/sizeof(D3D11_INPUT_ELEMENT_DESC),
bytecode->Data(), bytecode->Size(), &m_quadLayout);
CHECK(SUCCEEDED(hr), "create xfb encode quad vertex layout");
D3D::SetDebugObjectName(m_quadLayout, "xfb encoder quad layout");
bytecode->Release();
// Create pixel shader
m_pShader = D3D::CompileAndCreatePixelShader(XFB_ENCODE_PS);
if (!m_pShader)
{
ERROR_LOG(VIDEO, "XFB encode pixel shader failed to compile");
return;
}
D3D::SetDebugObjectName(m_pShader, "xfb encoder pixel shader");
// Create blend state
D3D11_BLEND_DESC bld = CD3D11_BLEND_DESC(CD3D11_DEFAULT());
hr = D3D::device->CreateBlendState(&bld, &m_xfbEncodeBlendState);
CHECK(SUCCEEDED(hr), "create xfb encode blend state");
D3D::SetDebugObjectName(m_xfbEncodeBlendState, "xfb encoder blend state");
// Create depth state
D3D11_DEPTH_STENCIL_DESC dsd = CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT());
dsd.DepthEnable = FALSE;
hr = D3D::device->CreateDepthStencilState(&dsd, &m_xfbEncodeDepthState);
CHECK(SUCCEEDED(hr), "create xfb encode depth state");
D3D::SetDebugObjectName(m_xfbEncodeDepthState, "xfb encoder depth state");
// Create rasterizer state
D3D11_RASTERIZER_DESC rd = CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT());
rd.CullMode = D3D11_CULL_NONE;
rd.DepthClipEnable = FALSE;
hr = D3D::device->CreateRasterizerState(&rd, &m_xfbEncodeRastState);
CHECK(SUCCEEDED(hr), "create xfb encode rasterizer state");
D3D::SetDebugObjectName(m_xfbEncodeRastState, "xfb encoder rast state");
// Create EFB texture sampler
D3D11_SAMPLER_DESC sd = CD3D11_SAMPLER_DESC(CD3D11_DEFAULT());
// FIXME: Should we really use point sampling here?
sd.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
hr = D3D::device->CreateSamplerState(&sd, &m_efbSampler);
CHECK(SUCCEEDED(hr), "create xfb encode texture sampler");
D3D::SetDebugObjectName(m_efbSampler, "xfb encoder texture sampler");
}
Asteroids::Asteroids(AsteroidsSimulation* asteroids, GUI* gui, bool warp)
: mAsteroids(asteroids)
, mGUI(gui)
, mSwapChain(nullptr)
, mDevice(nullptr)
, mDeviceCtxt(nullptr)
, mRenderTarget(nullptr)
, mRenderTargetView(nullptr)
, mDepthStencilView(nullptr)
, mDepthStencilState(nullptr)
, mInputLayout(nullptr)
, mIndexBuffer(nullptr)
, mVertexBuffer(nullptr)
, mVertexShader(nullptr)
, mPixelShader(nullptr)
, mDrawConstantBuffer(nullptr)
, mSkyboxVertexShader(nullptr)
, mSkyboxPixelShader(nullptr)
, mSkyboxConstantBuffer(nullptr)
, mSamplerState(nullptr)
{
memset(&mViewPort, 0, sizeof(mViewPort));
memset(&mScissorRect, 0, sizeof(mScissorRect));
memset(mTextures, 0, sizeof(mTextures));
memset(mTextureSRVs, 0, sizeof(mTextureSRVs));
// Create device and swap chain
{
IDXGIAdapter* adapter = nullptr;
D3D_DRIVER_TYPE driverType = ( warp ) ? D3D_DRIVER_TYPE_WARP : D3D_DRIVER_TYPE_HARDWARE;
HMODULE swModule = NULL;
UINT flags = 0;
D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_11_0 };
UINT numFeatureLevels = ARRAYSIZE(featureLevels);
UINT sdkVersion = D3D11_SDK_VERSION;
#ifdef _DEBUG
flags = flags | D3D11_CREATE_DEVICE_DEBUG;
#endif
auto hr = D3D11CreateDevice(adapter, driverType, swModule,
flags, featureLevels, numFeatureLevels, sdkVersion, &mDevice, nullptr, &mDeviceCtxt);
if (FAILED(hr)) {
// Try again without the debug flag...
flags = flags & ~D3D11_CREATE_DEVICE_DEBUG;
ThrowIfFailed(D3D11CreateDevice(adapter, driverType, swModule,
flags, featureLevels, numFeatureLevels, sdkVersion, &mDevice, nullptr, &mDeviceCtxt));
}
}
// create pipeline state
{
D3D11_INPUT_ELEMENT_DESC inputDesc[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
ThrowIfFailed(mDevice->CreateInputLayout(inputDesc, ARRAYSIZE(inputDesc),
g_asteroid_vs, sizeof(g_asteroid_vs), &mInputLayout));
{
D3D11_DEPTH_STENCIL_DESC desc = CD3D11_DEPTH_STENCIL_DESC(D3D11_DEFAULT);
desc.DepthFunc = D3D11_COMPARISON_GREATER_EQUAL;
ThrowIfFailed(mDevice->CreateDepthStencilState(&desc, &mDepthStencilState));
}
{
CD3D11_BLEND_DESC desc = CD3D11_BLEND_DESC(CD3D11_DEFAULT());
ThrowIfFailed(mDevice->CreateBlendState(&desc, &mBlendState));
// Premultiplied over blend
desc.RenderTarget[0].BlendEnable = TRUE;
desc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
ThrowIfFailed(mDevice->CreateBlendState(&desc, &mSpriteBlendState));
}
ThrowIfFailed(mDevice->CreateVertexShader(g_asteroid_vs, sizeof(g_asteroid_vs), NULL, &mVertexShader));
ThrowIfFailed(mDevice->CreatePixelShader(g_asteroid_ps_d3d11, sizeof(g_asteroid_ps_d3d11), NULL, &mPixelShader));
}
// create skybox pipeline state
{
D3D11_INPUT_ELEMENT_DESC inputDesc[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "UVFACE", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
ThrowIfFailed(mDevice->CreateInputLayout(inputDesc, ARRAYSIZE(inputDesc),
g_skybox_vs, sizeof(g_skybox_vs), &mSkyboxInputLayout));
ThrowIfFailed(mDevice->CreateVertexShader(g_skybox_vs, sizeof(g_skybox_vs), NULL, &mSkyboxVertexShader));
ThrowIfFailed(mDevice->CreatePixelShader(g_skybox_ps, sizeof(g_skybox_ps), NULL, &mSkyboxPixelShader));
}
// Sprites and fonts
{
D3D11_INPUT_ELEMENT_DESC inputDesc[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "UV", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
ThrowIfFailed(mDevice->CreateInputLayout(inputDesc, ARRAYSIZE(inputDesc),
g_sprite_vs, sizeof(g_sprite_vs), &mSpriteInputLayout));
ThrowIfFailed(mDevice->CreateVertexShader(g_sprite_vs, sizeof(g_sprite_vs), NULL, &mSpriteVertexShader));
ThrowIfFailed(mDevice->CreatePixelShader(g_sprite_ps, sizeof(g_sprite_ps), NULL, &mSpritePixelShader));
ThrowIfFailed(mDevice->CreatePixelShader(g_font_ps, sizeof(g_font_ps), NULL, &mFontPixelShader));
}
// Create draw constant buffer
{
D3D11_BUFFER_DESC desc = {};
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.ByteWidth = sizeof(DrawConstantBuffer);
desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
ThrowIfFailed(mDevice->CreateBuffer(&desc, nullptr, &mDrawConstantBuffer));
}
// Create skybox constant buffer
{
D3D11_BUFFER_DESC desc = {};
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.ByteWidth = sizeof(SkyboxConstantBuffer);
desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
ThrowIfFailed(mDevice->CreateBuffer(&desc, nullptr, &mSkyboxConstantBuffer));
}
// Create sampler
{
D3D11_SAMPLER_DESC desc = {};
desc.Filter = D3D11_FILTER_ANISOTROPIC;
desc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
desc.MinLOD = -D3D11_FLOAT32_MAX;
desc.MaxLOD = D3D11_FLOAT32_MAX;
desc.MipLODBias = 0.0f;
desc.MaxAnisotropy = TEXTURE_ANISO;
desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
ThrowIfFailed(mDevice->CreateSamplerState(&desc, &mSamplerState));
}
CreateMeshes();
InitializeTextureData();
CreateGUIResources();
// Load textures
ThrowIfFailed(CreateDDSTextureFromFile(mDevice, L"starbox_1024.dds", &mSkyboxSRV, true));
}
bool StateHolder::Initialize(ID3D11Device* device)
{
// Raster states
std::function<CD3D11_RASTERIZER_DESC()> rasterGenerators[RST_Count] =
{
[]() -> CD3D11_RASTERIZER_DESC {
CD3D11_RASTERIZER_DESC desc((CD3D11_DEFAULT()));
desc.CullMode = D3D11_CULL_BACK;
desc.FillMode = D3D11_FILL_SOLID;
desc.FrontCounterClockwise = FALSE;
return desc;
},
[]() -> CD3D11_RASTERIZER_DESC {
CD3D11_RASTERIZER_DESC desc((CD3D11_DEFAULT()));
desc.CullMode = D3D11_CULL_BACK;
desc.FillMode = D3D11_FILL_SOLID;
desc.FrontCounterClockwise = TRUE;
return desc;
},
[]() -> CD3D11_RASTERIZER_DESC {
CD3D11_RASTERIZER_DESC desc((CD3D11_DEFAULT()));
desc.CullMode = D3D11_CULL_BACK;
desc.FillMode = D3D11_FILL_WIREFRAME;
desc.FrontCounterClockwise = FALSE;
return desc;
},
[]() -> CD3D11_RASTERIZER_DESC {
CD3D11_RASTERIZER_DESC desc((CD3D11_DEFAULT()));
desc.CullMode = D3D11_CULL_BACK;
desc.FillMode = D3D11_FILL_WIREFRAME;
desc.FrontCounterClockwise = TRUE;
return desc;
},
};
for (auto gen = 0; gen < RST_Count; ++gen) {
if (FAILED(device->CreateRasterizerState(&rasterGenerators[gen](), m_RasterStates[gen].Receive())))
{
SLOG(Sev_Error, Fac_Rendering, "Unable to create raster state!");
return false;
}
}
// Blend states
std::function<CD3D11_BLEND_DESC()> blendGenerators[BLST_Count] =
{
[]() -> CD3D11_BLEND_DESC {
CD3D11_BLEND_DESC desc((CD3D11_DEFAULT()));
for (unsigned i = 0; i < 8; ++i) {
desc.RenderTarget[i].RenderTargetWriteMask = 0;
}
return desc;
},
[]() -> CD3D11_BLEND_DESC {
CD3D11_BLEND_DESC desc((CD3D11_DEFAULT()));
desc.AlphaToCoverageEnable = true;
desc.RenderTarget[0].BlendEnable = true;
return desc;
},
};
for (auto gen = 0; gen < BLST_Count; ++gen) {
if (FAILED(device->CreateBlendState(&blendGenerators[gen](), m_BlendStates[gen].Receive())))
{
SLOG(Sev_Error, Fac_Rendering, "Unable to create blend state!");
return false;
}
}
// Depth states
std::function<CD3D11_DEPTH_STENCIL_DESC()> depthGenerators[DSST_Count] =
{
[]()->CD3D11_DEPTH_STENCIL_DESC {
CD3D11_DEPTH_STENCIL_DESC desc((CD3D11_DEFAULT()));
desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
desc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
return desc;
},
[]()->CD3D11_DEPTH_STENCIL_DESC {
CD3D11_DEPTH_STENCIL_DESC desc((CD3D11_DEFAULT()));
desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
desc.DepthFunc = D3D11_COMPARISON_ALWAYS;
return desc;
},
};
for (auto gen = 0; gen < DSST_Count; ++gen) {
if (FAILED(device->CreateDepthStencilState(&depthGenerators[gen](), m_DepthStates[gen].Receive())))
{
SLOG(Sev_Error, Fac_Rendering, "Unable to create depth-stencil state!");
return false;
}
}
return true;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
// Initialize sample variables
m_nCurMeshIndex = CUBE_MESH;
m_bShowShadowMap = TRUE;
m_vLightPosition = FRMVECTOR3( 0.0f, 8.0f, 0.01f );
// Create the font
if( FALSE == m_Font.Create( "Tuffy12.pak" ) )
return FALSE;
// Load the packed resources
CFrmPackedResourceD3D resource;
if( FALSE == resource.LoadFromFile( "Textures.pak" ) )
return FALSE;
// Create the logo texture
m_pLogoTexture = resource.GetTexture( "Logo" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( "Press " FRM_FONT_KEY_0 " for Help", 1.0f, -1.0f, 1.0f );
m_UserInterface.AddIntVariable( &m_nShadowMapFBOTextureWidth , "Shadow Map Size", "%d" );
m_UserInterface.AddBoolVariable( &m_bUsePCF , "PCF On", "True", "False" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, "Toggle Help" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, "Next Model" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, "Next Floor" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, "Decrease Shadow Map Size" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_4, "Increase Shadow Map Size" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_5, "Toggle PCF" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_6, "Toggle Shadow Map Display" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_DPAD, "Rotate light" );
// Load the meshes
if( FALSE == m_Floor[ PLANE_FLOOR ].Load( "Plane.mesh" ) )
return FALSE;
if( FALSE == m_Floor[ PLANE_FLOOR ].MakeDrawable() )
return FALSE;
if( FALSE == m_Floor[ TERRAIN_FLOOR ].Load( "Terrain.mesh" ) )
return FALSE;
if( FALSE == m_Floor[ TERRAIN_FLOOR ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ CUBE_MESH ].Load( "Cube.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ CUBE_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ SPHERE_MESH ].Load( "Sphere.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ SPHERE_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ BUMPY_SPHERE_MESH ].Load( "BumpySphere.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ BUMPY_SPHERE_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ TORUS_MESH ].Load( "Torus.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ TORUS_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ ROCKET_MESH ].Load( "Rocket.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ ROCKET_MESH ].MakeDrawable() )
return FALSE;
// Initialize the shaders
if( FALSE == InitShaders() )
return FALSE;
// Initialize the camera and light perspective matrices
FLOAT32 fAspect = (FLOAT32)m_nWidth / (FLOAT32)m_nHeight;
m_matCameraPersp = FrmMatrixPerspectiveFovRH( FRM_PI/4.0f, fAspect, 1.0f, 100.0f );
m_matLightPersp = FrmMatrixPerspectiveFovRH( FRM_PI/4.0f, 1.0f, 5.0f, 20.0f );
// Setup the FBOs
m_nShadowMapFBOTextureExp = 7;
m_nShadowMapFBOTextureWidth = 2 << m_nShadowMapFBOTextureExp;
m_nShadowMapFBOTextureHeight = 2 << m_nShadowMapFBOTextureExp;
if( FALSE == CreateShadowMapFBO() )
return FALSE;
if( FALSE == CreateLightingFBO() )
return FALSE;
// Setup the camera view matrix
FRMVECTOR3 vCameraPosition = FRMVECTOR3( 0.0f, 4.0f, 10.0f );
FRMVECTOR3 vCameraLookAt = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
FRMVECTOR3 vCameraUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
m_matCameraView = FrmMatrixLookAtRH( vCameraPosition, vCameraLookAt, vCameraUp );
// Setup the floor's camera relative model view projection matrix
FRMMATRIX4X4 matFloorScale = FrmMatrixScale( 5.0f, 5.0f, 5.0f );
FRMMATRIX4X4 matFloorTranslate = FrmMatrixTranslate( 0.0f, -0.1f, 0.0f );
m_matFloorModel = FrmMatrixMultiply( matFloorScale, matFloorTranslate );
m_matCameraFloorModelView = FrmMatrixMultiply( m_matFloorModel, m_matCameraView );
m_matCameraFloorModelViewProj = FrmMatrixMultiply( m_matCameraFloorModelView, m_matCameraPersp );
m_matCameraFloorNormal = FrmMatrixNormal( m_matCameraFloorModelView );
// Setup the light look at and up vectors
m_vLightLookAt = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
m_vLightUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
// Create our scale and bias matrix that is used to convert the coordinates of vertices that are multiplied by a
// model view projection matrix from the range [-1, 1] to the range [0, 1], so that they can be used for texture lookups
m_matScaleAndBias.M( 0, 0 ) = 0.5f; m_matScaleAndBias.M( 0, 1 ) = 0.0f; m_matScaleAndBias.M( 0, 2 ) = 0.0f; m_matScaleAndBias.M( 0, 3 ) = 0.0f;
m_matScaleAndBias.M( 1, 0 ) = 0.0f; m_matScaleAndBias.M( 1, 1 ) = -0.5f; m_matScaleAndBias.M( 1, 2 ) = 0.0f; m_matScaleAndBias.M( 1, 3 ) = 0.0f;
m_matScaleAndBias.M( 2, 0 ) = 0.0f; m_matScaleAndBias.M( 2, 1 ) = 0.0f; m_matScaleAndBias.M( 2, 2 ) = 0.5f; m_matScaleAndBias.M( 2, 3 ) = 0.0f;
m_matScaleAndBias.M( 3, 0 ) = 0.5f; m_matScaleAndBias.M( 3, 1 ) = 0.5f; m_matScaleAndBias.M( 3, 2 ) = 0.5f; m_matScaleAndBias.M( 3, 3 ) = 1.0f;
// State blocks
D3D11_RASTERIZER_DESC rdesc = CD3D11_RASTERIZER_DESC(D3D11_DEFAULT);
rdesc.FrontCounterClockwise = TRUE; // Change the winding direction to match GL
D3DDevice()->CreateRasterizerState(&rdesc, &m_DefaultRasterizerState);
D3DDeviceContext()->RSSetState(m_DefaultRasterizerState.Get());
rdesc = CD3D11_RASTERIZER_DESC(D3D11_DEFAULT);
rdesc.CullMode = D3D11_CULL_NONE;
rdesc.DepthBias = 200;
rdesc.SlopeScaledDepthBias = 2.0f;
D3DDevice()->CreateRasterizerState(&rdesc, &m_PolygonOffsetRasterizerState);
D3D11_DEPTH_STENCIL_DESC dsdesc = CD3D11_DEPTH_STENCIL_DESC(D3D11_DEFAULT);
dsdesc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
D3DDevice()->CreateDepthStencilState(&dsdesc, &m_DepthLEqualStencilState);
D3DDeviceContext()->OMSetDepthStencilState( m_DepthLEqualStencilState.Get(), 0 );
return TRUE;
}
void DepthStencilStateManager::CreateStates(void)
{
D3D11_DEPTH_STENCIL_DESC willDesc = CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT());
willDesc.DepthEnable = false;
willDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
willDesc.StencilEnable = false;
willDesc.DepthEnable = true;
willDesc.DepthEnable = true;
willDesc.DepthFunc = D3D11_COMPARISON_GREATER;
willDesc.StencilEnable = true;
willDesc.FrontFace.StencilPassOp = willDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_REPLACE;
D3D11_DEPTH_STENCIL_DESC dssDesc = CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT());
dssDesc.DepthEnable = FALSE;
Renderer::m_pDevice->CreateDepthStencilState(&dssDesc, &m_pDepthStencilStates[DSS_NO_DEPTH]);
m_unStencilRefs[DSS_NO_DEPTH] = 0;
dssDesc.DepthEnable = TRUE;
Renderer::m_pDevice->CreateDepthStencilState(&dssDesc, &m_pDepthStencilStates[DSS_DEFAULT]);
m_unStencilRefs[DSS_DEFAULT] = 0;
dssDesc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
Renderer::m_pDevice->CreateDepthStencilState(&dssDesc, &m_pDepthStencilStates[DSS_LESS_EQUAL]);
m_unStencilRefs[DSS_LESS_EQUAL] = 0;
dssDesc.DepthFunc = D3D11_COMPARISON_GREATER;
dssDesc.StencilEnable = TRUE;
dssDesc.FrontFace.StencilPassOp =
dssDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_REPLACE;
dssDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
Renderer::m_pDevice->CreateDepthStencilState(&dssDesc, &m_pDepthStencilStates[DSS_DEFERRED_LIGHT_1]);
m_unStencilRefs[DSS_DEFERRED_LIGHT_1] = 0x1;
willDesc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
willDesc.FrontFace.StencilFunc = willDesc.BackFace.StencilFunc = D3D11_COMPARISON_EQUAL;
willDesc.FrontFace.StencilPassOp = willDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_INCR;
dssDesc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
dssDesc.FrontFace.StencilFunc =
dssDesc.BackFace.StencilFunc = D3D11_COMPARISON_EQUAL;
dssDesc.FrontFace.StencilPassOp =
dssDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_INCR;
Renderer::m_pDevice->CreateDepthStencilState(&dssDesc, &m_pDepthStencilStates[DSS_DEFERRED_LIGHT_2]);
m_unStencilRefs[DSS_DEFERRED_LIGHT_2] = 0x1;
dssDesc.FrontFace.StencilPassOp =
dssDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
willDesc.DepthEnable = false;
willDesc.FrontFace.StencilPassOp = willDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
/*dssDesc.FrontFace.StencilFunc =
dssDesc.BackFace.StencilFunc = D3D11_COMPARISON_NEVER;
dssDesc.FrontFace.StencilFailOp =
dssDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_ZERO;*/
dssDesc.DepthEnable = FALSE;
Renderer::m_pDevice->CreateDepthStencilState(&dssDesc, &m_pDepthStencilStates[DSS_LIGHT_OUTSIDE_FINAL]);
m_unStencilRefs[DSS_LIGHT_OUTSIDE_FINAL] = 0x2;
Renderer::m_pDevice->CreateDepthStencilState(&dssDesc, &m_pDepthStencilStates[DSS_LIGHT_INSIDE_FINAL]);
m_unStencilRefs[DSS_LIGHT_INSIDE_FINAL] = 0x1;
}
bool D3D11Context::startup (void* hwnd)
{
UINT flags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#ifdef _DEBUG
flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0,
};
if (m_failed (::D3D11CreateDevice (nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, flags, featureLevels, numElementsInArray (featureLevels), D3D11_SDK_VERSION, device, &featureLevel, contextIM)))
{
if (m_failed (::D3D11CreateDevice (nullptr, D3D_DRIVER_TYPE_WARP, nullptr, flags, featureLevels, numElementsInArray (featureLevels), D3D11_SDK_VERSION, device, &featureLevel, contextIM)))
return false;
}
Hold<IDXGIDevice2> dxgiDevice;
if (m_failed (device.as (dxgiDevice)))
return false;
Hold<IDXGIAdapter> dxgiAdapter;
if (m_failed (dxgiDevice->GetAdapter (dxgiAdapter)))
return false;
Hold<IDXGIFactory2> dxgiFactory;
if (m_failed (dxgiAdapter->GetParent (__uuidof (IDXGIFactory2), dxgiFactory)))
return false;
DXGI_SWAP_CHAIN_DESC1 desc;
desc.Width = 0;
desc.Height = 0;
desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
desc.Stereo = false;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
desc.BufferCount = 2;
desc.Scaling = DXGI_SCALING_STRETCH; // DXGI_SCALING_NONE is not supported on Windows7
desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
desc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;
desc.Flags = 0;
if (m_failed (dxgiFactory->CreateSwapChainForHwnd (device, (HWND)hwnd, &desc, nullptr, nullptr, swapchain)))
return false;
Hold<ID3D11Texture2D> backBuf;
if (m_failed (swapchain->GetBuffer (0, __uuidof (ID3D11Texture2D), backBuf)))
return false;
if (m_failed (device->CreateRenderTargetView (backBuf, nullptr, backBufRTView)))
return false;
RECT rect;
::GetClientRect ((HWND)hwnd, &rect);
if (m_isnull (depthBuf.set (createTexture2DRT (rect.right - rect.left, rect.bottom - rect.top, 1, DXGI_FORMAT_R32_TYPELESS, DXGI_FORMAT_D32_FLOAT))))
return false;
if (m_isnull (depthBufDSView.set (createDepthStencilView (depthBuf, 0, DXGI_FORMAT_D32_FLOAT))))
return false;
if (m_isnull (depthBufSRView.set (createShaderResourceView (depthBuf, DXGI_FORMAT_R32_FLOAT))))
return false;
// common sampler states
{
D3D11_SAMPLER_DESC _ = CD3D11_SAMPLER_DESC (D3D11_DEFAULT);
_.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
_.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
_.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
_.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
if (m_isnull (sampWrapLinear.set (createSamplerState (_))))
return false;
}
{
D3D11_SAMPLER_DESC _ = CD3D11_SAMPLER_DESC (D3D11_DEFAULT);
_.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
_.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
_.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
_.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
if (m_isnull (sampWrapPoint.set (createSamplerState (_))))
return false;
}
{
D3D11_SAMPLER_DESC _ = CD3D11_SAMPLER_DESC (D3D11_DEFAULT);
_.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
_.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
_.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
_.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
if (m_isnull (sampClampLinear.set (createSamplerState (_))))
return false;
}
{
D3D11_SAMPLER_DESC _ = CD3D11_SAMPLER_DESC (D3D11_DEFAULT);
_.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
_.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
_.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
_.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
if (m_isnull (sampClampPoint.set (createSamplerState (_))))
return false;
}
// common rasterizer state
{
D3D11_RASTERIZER_DESC _ = CD3D11_RASTERIZER_DESC (D3D11_DEFAULT);
_.CullMode = D3D11_CULL_NONE;
_.FrontCounterClockwise = FALSE;
if (m_isnull (rastCullNone.set (createRasterizerState (_))))
return false;
}
{
D3D11_RASTERIZER_DESC _ = CD3D11_RASTERIZER_DESC (D3D11_DEFAULT);
_.CullMode = D3D11_CULL_FRONT;
_.FrontCounterClockwise = FALSE;
if (m_isnull (rastCWCullFront.set (createRasterizerState (_))))
return false;
}
{
D3D11_RASTERIZER_DESC _ = CD3D11_RASTERIZER_DESC (D3D11_DEFAULT);
_.CullMode = D3D11_CULL_BACK;
_.FrontCounterClockwise = FALSE;
if (m_isnull (rastCWCullBack.set (createRasterizerState (_))))
return false;
}
{
D3D11_RASTERIZER_DESC _ = CD3D11_RASTERIZER_DESC (D3D11_DEFAULT);
_.CullMode = D3D11_CULL_FRONT;
_.FrontCounterClockwise = TRUE;
if (m_isnull (rastCCWCullFront.set (createRasterizerState (_))))
return false;
}
{
D3D11_RASTERIZER_DESC _ = CD3D11_RASTERIZER_DESC (D3D11_DEFAULT);
_.CullMode = D3D11_CULL_BACK;
_.FrontCounterClockwise = TRUE;
if (m_isnull (rastCCWCullBack.set (createRasterizerState (_))))
return false;
}
// common depth stencil state
{
D3D11_DEPTH_STENCIL_DESC _ = CD3D11_DEPTH_STENCIL_DESC (D3D11_DEFAULT);
_.DepthEnable = TRUE;
_.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
if (m_isnull (depthTestOnWriteOn.set (createDepthStencilState (_))))
return false;
}
{
D3D11_DEPTH_STENCIL_DESC _ = CD3D11_DEPTH_STENCIL_DESC (D3D11_DEFAULT);
_.DepthEnable = TRUE;
_.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
if (m_isnull (depthTestOnWriteOff.set (createDepthStencilState (_))))
return false;
}
{
D3D11_DEPTH_STENCIL_DESC _ = CD3D11_DEPTH_STENCIL_DESC (D3D11_DEFAULT);
_.DepthEnable = FALSE;
_.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
if (m_isnull (depthTestOffWriteOn.set (createDepthStencilState (_))))
return false;
}
{
D3D11_DEPTH_STENCIL_DESC _ = CD3D11_DEPTH_STENCIL_DESC (D3D11_DEFAULT);
_.DepthEnable = FALSE;
_.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
if (m_isnull (depthTestOffWriteOff.set (createDepthStencilState (_))))
return false;
}
return true;
}
