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();
}
ID3D11RasterizerState* StateCache::Get(RasterizerState state)
{
auto it = m_raster.find(state.packed);
if (it != m_raster.end())
return it->second;
D3D11_RASTERIZER_DESC rastdc = CD3D11_RASTERIZER_DESC(state.wireframe ? D3D11_FILL_WIREFRAME : D3D11_FILL_SOLID,
state.cull_mode,
false, 0, 0.f, 0, true, true, false, false);
ID3D11RasterizerState* res = nullptr;
HRESULT hr = D3D::device->CreateRasterizerState(&rastdc, &res);
if (FAILED(hr)) PanicAlert("Failed to create rasterizer state at %s %d\n", __FILE__, __LINE__);
D3D::SetDebugObjectName((ID3D11DeviceChild*)res, "rasterizer state used to emulate the GX pipeline");
m_raster.insert(std::make_pair(state.packed, res));
return res;
}
RenderDevice* Gfx_CreateDevice(Window* window, const RenderDeviceConfig& cfg)
{
(void)cfg; // TODO
RenderDevice* dev = new RenderDevice;
dev->window = window;
dev->vsync = cfg.use_vertical_sync ? 1 : 0;
dev->default_context = new RenderContext;
dev->default_context->resources = &dev->resources;
// create d3d11 device and essential resources
HWND hwnd = *(HWND*)window->native_window_handle();
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory( &sd, sizeof( sd ) );
sd.BufferCount = 1;
sd.BufferDesc.Width = window->width();
sd.BufferDesc.Height = window->height();
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = hwnd;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
uint32 flags = D3D11_CREATE_DEVICE_SINGLETHREADED;
#ifdef _DEBUG
flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif //_DEBUG
D3D_DRIVER_TYPE type = D3D_DRIVER_TYPE_HARDWARE;
IDXGIAdapter* adapter = NULL;
if( cfg.use_nvperfhud )
{
IDXGIAdapter* enumerated_adapter = NULL;
IDXGIFactory* factory = NULL;
D3D_CALL( CreateDXGIFactory(__uuidof(IDXGIFactory),(void**)&factory) );
for( uint32 i=0; factory->EnumAdapters(i,&enumerated_adapter) != DXGI_ERROR_NOT_FOUND; ++i )
{
DXGI_ADAPTER_DESC adapter_desc;
if(enumerated_adapter->GetDesc(&adapter_desc) != S_OK)
{
continue;
}
if(wcsstr(adapter_desc.Description,L"PerfHUD") != 0)
{
type = D3D_DRIVER_TYPE_REFERENCE;
adapter = enumerated_adapter;
break;
}
}
SafeRelease(factory);
}
D3D_FEATURE_LEVEL features[] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
D3D_FEATURE_LEVEL_9_3,
D3D_FEATURE_LEVEL_9_2,
D3D_FEATURE_LEVEL_9_1
};
const uint32 num_features = sizeof(features) / sizeof(features[0]);
D3D_FEATURE_LEVEL supported_features = D3D_FEATURE_LEVEL_9_1;
// Create device
D3D_CALL( D3D11CreateDeviceAndSwapChain(
adapter, type, NULL, flags, features, num_features,
D3D11_SDK_VERSION, &sd, &dev->swap_chain, &dev->native,
&supported_features, &dev->default_context->native) );
// Set-up default Colour and Depth surfaces
dx11_acquire_back_buffer(dev);
dx11_setup_back_buffer(dev);
// create default pixel and vertex constant buffers
D3D11_BUFFER_DESC desc;
desc.ByteWidth = MaxShaderConstants*sizeof(Vector4);
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
D3D_CALL(dev->native->CreateBuffer(&desc, NULL, &dev->default_context->ps_cb));
D3D_CALL(dev->native->CreateBuffer(&desc, NULL, &dev->default_context->vs_cb));
// Hack -- enable scissor rect state by default
D3D11_RASTERIZER_DESC rasterizer_desc = CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT());
rasterizer_desc.ScissorEnable = TRUE;
dev->native->CreateRasterizerState(&rasterizer_desc, &dev->rasterizer_state);
dev->default_context->native->RSSetState(dev->rasterizer_state);
// all done
dev->resize_listener = new WindowResizeListener(window);
return dev;
}
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");
}
bool InitD3D11QuadRendering( RENDERER_SETTINGS * settings )
{
ID3DBlob * pCode = NULL;
ID3DBlob * pErrors = NULL;
if (D3DCompile( defaultVertexShader, strlen(defaultVertexShader), NULL, NULL, NULL, "main", "vs_4_0", NULL, NULL, &pCode, &pErrors ) != S_OK)
{
printf("[Renderer] D3DCompile failed\n");
return false;
}
if (pDevice->CreateVertexShader( pCode->GetBufferPointer(), pCode->GetBufferSize(), NULL, &pVertexShader ) != S_OK)
{
printf("[Renderer] CreateVertexShader failed\n");
return false;
}
//////////////////////////////////////////////////////////////////////////
static float pQuad[] = {
-1.0, -1.0, 0.5, 0.0, 0.0,
-1.0, 1.0, 0.5, 0.0, 1.0,
1.0, -1.0, 0.5, 1.0, 0.0,
1.0, 1.0, 0.5, 1.0, 1.0,
};
D3D11_BUFFER_DESC desc;
ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
desc.ByteWidth = sizeof(float) * 5 * 4;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
D3D11_SUBRESOURCE_DATA subData;
ZeroMemory(&subData, sizeof(D3D11_SUBRESOURCE_DATA));
subData.pSysMem = pQuad;
if (pDevice->CreateBuffer(&desc, &subData, &pFullscreenQuadVB) != S_OK)
{
printf("[Renderer] CreateBuffer failed\n");
return false;
}
static D3D11_INPUT_ELEMENT_DESC pQuadDesc[] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0 * sizeof(float), D3D11_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT , 0, 3 * sizeof(float), D3D11_INPUT_PER_VERTEX_DATA, 0},
};
if (pDevice->CreateInputLayout( pQuadDesc, 2, pCode->GetBufferPointer(), pCode->GetBufferSize(), &pFullscreenQuadLayout) != S_OK)
{
printf("[Renderer] CreateInputLayout failed\n");
return false;
}
//////////////////////////////////////////////////////////////////////////
D3D11_VIEWPORT viewport;
ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = settings->nWidth;
viewport.Height = settings->nHeight;
pContext->RSSetViewports(1, &viewport);
//////////////////////////////////////////////////////////////////////////
D3D11_SAMPLER_DESC sampDesc = CD3D11_SAMPLER_DESC( CD3D11_DEFAULT() );
sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.Filter = D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT;
if (pDevice->CreateSamplerState( &sampDesc, &pFullscreenQuadSamplerState ) != S_OK)
return false;
//////////////////////////////////////////////////////////////////////////
D3D11_BUFFER_DESC cbDesc;
ZeroMemory( &cbDesc, sizeof(D3D11_BUFFER_DESC) );
cbDesc.ByteWidth = sizeof( pFullscreenQuadConstants );
cbDesc.Usage = D3D11_USAGE_DYNAMIC;
cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
ZeroMemory( &subData, sizeof(D3D11_SUBRESOURCE_DATA) );
subData.pSysMem = &pFullscreenQuadConstants;
if (pDevice->CreateBuffer( &cbDesc, &subData, &pFullscreenQuadConstantBuffer ) != S_OK)
return false;
//////////////////////////////////////////////////////////////////////////
D3D11_BLEND_DESC blendDesc = CD3D11_BLEND_DESC( CD3D11_DEFAULT() );
if (pDevice->CreateBlendState( &blendDesc, &pFullscreenQuadBlendState ) != S_OK)
return false;
D3D11_RASTERIZER_DESC rastDesc = CD3D11_RASTERIZER_DESC( CD3D11_DEFAULT() );
if (pDevice->CreateRasterizerState( &rastDesc, &pFullscreenQuadRasterizerState ) != S_OK)
return false;
return 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;
}
void sparse_voxel_octree::create(ID3D11Device* device, UINT volume_size)
{
profiler_.create(device);
volume_size_ = volume_size;
UINT voxel_count = volume_size_ * volume_size_ * volume_size_;
UINT mips = static_cast<UINT>(std::log2(volume_size_));
// create volume(s)
D3D11_TEXTURE3D_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_RENDER_TARGET;
desc.Width = volume_size;
desc.Height = volume_size;
desc.Depth = volume_size;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
desc.MiscFlags = D3D11_RESOURCE_MISC_GENERATE_MIPS;
desc.MipLevels = mips;
assert_hr(device->CreateTexture3D(&desc, nullptr, &v_normal_));
assert_hr(device->CreateTexture3D(&desc, nullptr, &v_rho_));
// create unordered access view for volume(s)
D3D11_UNORDERED_ACCESS_VIEW_DESC uav_desc;
ZeroMemory(&uav_desc, sizeof(uav_desc));
uav_desc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
uav_desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE3D;
uav_desc.Texture3D.FirstWSlice = 0;
uav_desc.Texture3D.MipSlice = 0;
uav_desc.Texture3D.WSize = volume_size;
assert_hr(device->CreateUnorderedAccessView(v_normal_, &uav_desc, &uav_v_normal_));
assert_hr(device->CreateUnorderedAccessView(v_rho_, &uav_desc, &uav_v_rho_));
// create shader resource view for volume(s)
D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc;
srv_desc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
srv_desc.Texture3D.MostDetailedMip = 0;
srv_desc.Texture3D.MipLevels = mips;
assert_hr(device->CreateShaderResourceView(v_normal_, &srv_desc, &srv_v_normal_));
assert_hr(device->CreateShaderResourceView(v_rho_, &srv_desc, &srv_v_rho_));
D3D11_BLEND_DESC bld;
ZeroMemory(&bld, sizeof(D3D11_BLEND_DESC));
bld.IndependentBlendEnable = TRUE;
for (size_t i = 0; i < 6; ++i)
{
bld.RenderTarget[i].BlendEnable = TRUE;
bld.RenderTarget[i].SrcBlend = D3D11_BLEND_ONE;
bld.RenderTarget[i].DestBlend = D3D11_BLEND_ONE;
bld.RenderTarget[i].SrcBlendAlpha = D3D11_BLEND_ONE;
bld.RenderTarget[i].DestBlendAlpha = D3D11_BLEND_ONE;
bld.RenderTarget[i].BlendOp = D3D11_BLEND_OP_MAX;
bld.RenderTarget[i].BlendOpAlpha = D3D11_BLEND_OP_MAX;
bld.RenderTarget[i].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
}
assert_hr(device->CreateBlendState(&bld, &bs_voxelize_));
CD3D11_RASTERIZER_DESC raster_desc = CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT());
raster_desc.FrontCounterClockwise = true;
raster_desc.CullMode = D3D11_CULL_NONE;
assert_hr(device->CreateRasterizerState(&raster_desc, &no_culling_));
cb_parameters_.create(device);
cb_gi_parameters_.create(device);
DirectX::XMStoreFloat4x4(&world_to_svo_, DirectX::XMMatrixIdentity());
}
DEMO_APP::DEMO_APP(HINSTANCE hinst, WNDPROC proc)
{
// ****************** BEGIN WARNING ***********************//
// WINDOWS CODE, I DON'T TEACH THIS YOU MUST KNOW IT ALREADY!
application = hinst;
appWndProc = proc;
WNDCLASSEX wndClass;
ZeroMemory(&wndClass, sizeof(wndClass));
wndClass.cbSize = sizeof(WNDCLASSEX);
wndClass.lpfnWndProc = appWndProc;
wndClass.lpszClassName = L"DirectXApplication";
wndClass.hInstance = application;
wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOWFRAME);
//wndClass.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_FSICON));
RegisterClassEx(&wndClass);
RECT window_size = { 0, 0, BACKBUFFER_WIDTH, BACKBUFFER_HEIGHT };
AdjustWindowRect(&window_size, WS_OVERLAPPEDWINDOW, false);
window = CreateWindow(L"DirectXApplication", L"Graphics II Project", WS_OVERLAPPEDWINDOW & ~(WS_THICKFRAME | WS_MAXIMIZEBOX),
CW_USEDEFAULT, CW_USEDEFAULT, window_size.right - window_size.left, window_size.bottom - window_size.top,
NULL, NULL, application, this);
ShowWindow(window, SW_SHOW);
//********************* END WARNING ************************//
// TODO: PART 1 STEP 3a
DXGI_SWAP_CHAIN_DESC swapDescription;
ZeroMemory(&swapDescription, sizeof(swapDescription));
swapDescription.BufferCount = 1;
swapDescription.BufferDesc.Width = BACKBUFFER_WIDTH;
swapDescription.BufferDesc.Height = BACKBUFFER_HEIGHT;
swapDescription.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapDescription.BufferDesc.RefreshRate.Numerator = 60;
swapDescription.BufferDesc.RefreshRate.Denominator = 1;
swapDescription.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapDescription.OutputWindow = window;
swapDescription.SampleDesc.Count = 4;
swapDescription.SampleDesc.Quality = D3D11_CENTER_MULTISAMPLE_PATTERN;
swapDescription.Windowed = true;
// TODO: PART 1 STEP 3b
D3D_FEATURE_LEVEL list[6] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
D3D_FEATURE_LEVEL_9_3,
D3D_FEATURE_LEVEL_9_2,
D3D_FEATURE_LEVEL_9_1,
};
HRESULT test =
D3D11CreateDeviceAndSwapChain(nullptr, // which screen to draw on
D3D_DRIVER_TYPE_HARDWARE, // use the hardware
NULL,
D3D11_CREATE_DEVICE_DEBUG, // how to treat the device
list, 6, // array of feature levels and how many there are (null sets a default value)
D3D11_SDK_VERSION, // whatever sdk we are currently using
&swapDescription,
&swapChain, &theDevice, // output parameters
nullptr, &devContext);
ID3D11Texture2D* DepthStencil = NULL;
D3D11_TEXTURE2D_DESC depthDescription;
depthDescription.Width = BACKBUFFER_WIDTH;
depthDescription.Height = BACKBUFFER_HEIGHT;
depthDescription.MipLevels = 1;
depthDescription.ArraySize = 1;
depthDescription.Format = DXGI_FORMAT_D32_FLOAT;
depthDescription.SampleDesc.Count = 4;
depthDescription.SampleDesc.Quality = D3D11_CENTER_MULTISAMPLE_PATTERN;
depthDescription.Usage = D3D11_USAGE_DEFAULT;
depthDescription.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthDescription.CPUAccessFlags = 0;
depthDescription.MiscFlags = 0;
HRESULT depthHR;
depthHR = theDevice->CreateTexture2D(&depthDescription, NULL, &DepthStencil);
#pragma region STENCIL
//D3D11_DEPTH_STENCIL_DESC depthStencilDescription;
//ZeroMemory(&depthStencilDescription, sizeof(depthStencilDescription));
//// Depth test parameters
//depthStencilDescription.DepthEnable = true;
//depthStencilDescription.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
//depthStencilDescription.DepthFunc = D3D11_COMPARISON_LESS;
//// Stencil test parameters
//depthStencilDescription.StencilEnable = true;
//depthStencilDescription.StencilReadMask = 0xFF;
//depthStencilDescription.StencilWriteMask = 0xFF;
//// Stencil operations if pixel is front-facing
//depthStencilDescription.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
//depthStencilDescription.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
//depthStencilDescription.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
//depthStencilDescription.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
//// Stencil operations if pixel is back-facing
//depthStencilDescription.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
//depthStencilDescription.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
//depthStencilDescription.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
//depthStencilDescription.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Create depth stencil state
//ID3D11DepthStencilState * pDSState;
//HRESULT DSS;
//DSS = theDevice->CreateDepthStencilState(&depthStencilDescription, &pDSState);
//D3D11_DEPTH_STENCIL_VIEW_DESC DSVdesc;
//ZeroMemory(&DSVdesc, sizeof(DSVdesc));
//DSVdesc.Format = DXGI_FORMAT_D32_FLOAT;
//DSVdesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
//DSVdesc.Texture2D.MipSlice = 0;
#pragma endregion
HRESULT DSVHR;
DSVHR = theDevice->CreateDepthStencilView(DepthStencil, NULL, &DepthStencilView);
//pDSState->Release();
DepthStencil->Release();
swapChain->GetBuffer(0, __uuidof(backBuffer), reinterpret_cast<void**>(&backBuffer));
HRESULT hr = theDevice->CreateRenderTargetView(backBuffer, NULL, &targetView);
viewPort.TopLeftX = 0.0f;
viewPort.TopLeftY = 0.0f;
viewPort.Width = BACKBUFFER_WIDTH;
viewPort.Height = BACKBUFFER_HEIGHT;
viewPort.MinDepth = 0.0f;
viewPort.MaxDepth = 1.0f;
otherPort.TopLeftX = 0.0f;
otherPort.TopLeftY = 0.0f;
otherPort.Width = BACKBUFFER_WIDTH / 4;
otherPort.Height = BACKBUFFER_HEIGHT / 4;
otherPort.MinDepth = 0.0f;
otherPort.MaxDepth = 1.0f;
#if 1
theDevice->CreateVertexShader(SkyVShader, sizeof(SkyVShader), nullptr, &SkyBox.pVShader);
theDevice->CreatePixelShader(SkyPShader, sizeof(SkyPShader), nullptr, &SkyBox.pPShader);
D3D11_INPUT_ELEMENT_DESC skyLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "UV", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
theDevice->CreateInputLayout(skyLayout, ARRAYSIZE(skyLayout), SkyVShader, sizeof(SkyVShader), &SkyBox.pInputLayout);
SkyBox.Initialize(L"sky.obj", L"SkyboxOcean.dds");
#if 1
theDevice->CreateVertexShader(InstanceVShader, sizeof(InstanceVShader), nullptr, &Pyramid.pVShader);
theDevice->CreatePixelShader(Trivial_PS, sizeof(Trivial_PS), nullptr, &Pyramid.pPShader);
D3D11_INPUT_ELEMENT_DESC vLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "UV", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
// TODO: PART 2 STEP 8b
unsigned int numElements = ARRAYSIZE(vLayout);
theDevice->CreateInputLayout(vLayout, numElements, InstanceVShader, sizeof(InstanceVShader), &Pyramid.pInputLayout);
Pyramid.numInstances = 4;
Pyramid.instanced = true;
Pyramid.Initialize(L"test_pyramid_triangle.obj", L"metallock.dds");
Translate(Pyramid.worldMatrix, 0.0f, 0.0f, 3.0f);
//theDevice->CreateVertexShader(VertexSlimShader, sizeof(VertexSlimShader), nullptr, &TexturePyramid.pVShader);
//theDevice->CreatePixelShader(Trivial_PS, sizeof(Trivial_PS), nullptr, &TexturePyramid.pPShader);
//theDevice->CreateInputLayout(vLayout, numElements, VertexSlimShader, sizeof(VertexSlimShader), &TexturePyramid.pInputLayout);
//TexturePyramid.Initialize(L"test_pyramid_trianlge.obj", L"checkerboard.dds");
float length = 5.0f;
VertexOBJ quad[4] =
{
{ -length, 0.0f, length, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f },
{ length, 0.0f, length, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f },
{ -length, 0.0f, -length, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f },
{ length, 0.0f, -length, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f }
};
unsigned int quadIndices[6] =
{
0, 1, 3,
0, 3, 2
};
theDevice->CreateVertexShader(VertexSlimShader, sizeof(VertexSlimShader), nullptr, &Quad.pVShader);
theDevice->CreatePixelShader(Trivial_PS, sizeof(Trivial_PS), nullptr, &Quad.pPShader);
theDevice->CreateInputLayout(skyLayout, 3, VertexSlimShader, sizeof(VertexSlimShader), &Quad.pInputLayout);
Quad.pVertices = quad;
Quad.numVertices = 4;
Quad.pIndices = quadIndices;
Quad.numIndices = 6;
Quad.Initialize(nullptr, L"checkerboard.dds");
Translate(Quad.worldMatrix, 0.0f, -1.0f, 3.0f);
theDevice->CreateVertexShader(PassToGeoVShader, sizeof(PassToGeoVShader), nullptr, &QuadSeed.pVShader);
theDevice->CreatePixelShader(Trivial_PS, sizeof(Trivial_PS), nullptr, &QuadSeed.pPShader);
theDevice->CreateGeometryShader(QuadCreator, sizeof(QuadCreator), nullptr, &QuadSeed.pGShader);
theDevice->CreateInputLayout(skyLayout, 3, PassToGeoVShader, sizeof(PassToGeoVShader), &QuadSeed.pInputLayout);
theDevice->CreateVertexShader(VertexSlimShader, sizeof(VertexSlimShader), nullptr, &Tree.pVShader);
theDevice->CreatePixelShader(Trivial_PS, sizeof(Trivial_PS), nullptr, &Tree.pPShader);
theDevice->CreateInputLayout(skyLayout, 3, VertexSlimShader, sizeof(VertexSlimShader), &Tree.pInputLayout);
Tree.Initialize(L"the_tree.obj", L"treeTexture.dds");
Translate(Tree.worldMatrix, 2.0f, -1.0f, 3.0f);
theDevice->CreateVertexShader(VertexSlimShader, sizeof(VertexSlimShader), nullptr, &Tree1.pVShader);
theDevice->CreatePixelShader(Trivial_PS, sizeof(Trivial_PS), nullptr, &Tree1.pPShader);
theDevice->CreateInputLayout(skyLayout, 3, VertexSlimShader, sizeof(VertexSlimShader), &Tree1.pInputLayout);
Tree1.Initialize(L"the_tree.obj", L"treeTexture.dds");
Translate(Tree1.worldMatrix, 2.0f, -1.0f, 0.0f);
theDevice->CreateVertexShader(VertexSlimShader, sizeof(VertexSlimShader), nullptr, &Tree2.pVShader);
theDevice->CreatePixelShader(Trivial_PS, sizeof(Trivial_PS), nullptr, &Tree2.pPShader);
theDevice->CreateInputLayout(skyLayout, 3, VertexSlimShader, sizeof(VertexSlimShader), &Tree2.pInputLayout);
Tree2.Initialize(L"the_tree.obj", L"treeTexture.dds");
Translate(Tree2.worldMatrix, 2.0f, -1.0f, 7.0f);
theDevice->CreateVertexShader(PassToGeoVShader, sizeof(PassToGeoVShader), nullptr, &PostQuad.pVShader);
theDevice->CreatePixelShader(PostProcess, sizeof(PostProcess), nullptr, &PostQuad.pPShader);
theDevice->CreateGeometryShader(PostGeoShader, sizeof(PostGeoShader), nullptr, &PostQuad.pGShader);
theDevice->CreateInputLayout(skyLayout, 3, PassToGeoVShader, sizeof(PassToGeoVShader), &PostQuad.pInputLayout);
VertexOBJ seed = { 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f };
unsigned int x = 0;
QuadSeed.pVertices = &seed;
QuadSeed.numVertices = 1;
QuadSeed.pIndices = &x;
QuadSeed.numIndices = 1;
VertexOBJ center;
PostQuad.pVertices = ¢er;
PostQuad.numVertices = 1;
PostQuad.pIndices = &x;
PostQuad.numIndices = 1;
D3D11_TEXTURE2D_DESC viewDesc;
ZeroMemory(&viewDesc, sizeof(viewDesc));
viewDesc.Width = BACKBUFFER_WIDTH;
viewDesc.Height = BACKBUFFER_HEIGHT;
viewDesc.MipLevels = 1;
viewDesc.ArraySize = 1;
viewDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
viewDesc.SampleDesc.Count = 4;
viewDesc.SampleDesc.Quality = D3D11_CENTER_MULTISAMPLE_PATTERN;
viewDesc.Usage = D3D11_USAGE_DEFAULT;
viewDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
viewDesc.CPUAccessFlags = 0;
viewDesc.MiscFlags = D3D11_RESOURCE_MISC_GENERATE_MIPS;
theDevice->CreateTexture2D(&viewDesc, NULL, &renderTexture);
D3D11_TEXTURE2D_DESC postDesc;
ZeroMemory(&postDesc, sizeof(postDesc));
postDesc.Width = BACKBUFFER_WIDTH;
postDesc.Height = BACKBUFFER_HEIGHT;
postDesc.MipLevels = 1;
postDesc.ArraySize = 1;
postDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
postDesc.SampleDesc.Count = 4;
postDesc.SampleDesc.Quality = D3D11_CENTER_MULTISAMPLE_PATTERN;
postDesc.Usage = D3D11_USAGE_DEFAULT;
postDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
postDesc.CPUAccessFlags = 0;
postDesc.MiscFlags = D3D11_RESOURCE_MISC_GENERATE_MIPS;
theDevice->CreateTexture2D(&postDesc, NULL, &postTexture);
viewDesc.SampleDesc.Count = 1;
viewDesc.SampleDesc.Quality = 0;
theDevice->CreateTexture2D(&viewDesc, nullptr, &fixerTexture);
D3D11_RENDER_TARGET_VIEW_DESC rendViewDesc;
ZeroMemory(&rendViewDesc, sizeof(rendViewDesc));
rendViewDesc.Format = viewDesc.Format;
rendViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
rendViewDesc.Texture2D.MipSlice = 0;
theDevice->CreateRenderTargetView(renderTexture, &rendViewDesc, &anotherView);
theDevice->CreateRenderTargetView(postTexture, &rendViewDesc, &postProcessView);
D3D11_SHADER_RESOURCE_VIEW_DESC shadeDesc;
ZeroMemory(&shadeDesc, sizeof(shadeDesc));
shadeDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
shadeDesc.Format = viewDesc.Format;
shadeDesc.Texture2D.MostDetailedMip = 0;
shadeDesc.Texture2D.MipLevels = 5;
theDevice->CreateShaderResourceView(renderTexture, &shadeDesc, &QuadSeed.pShaderResource);
theDevice->CreateShaderResourceView(postTexture, &shadeDesc, &PostQuad.pShaderResource);
D3D11_SHADER_RESOURCE_VIEW_DESC yetAnotherShadeDesc;
ZeroMemory(&yetAnotherShadeDesc, sizeof(yetAnotherShadeDesc));
yetAnotherShadeDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
yetAnotherShadeDesc.Format = viewDesc.Format;
yetAnotherShadeDesc.Texture2D.MostDetailedMip = 0;
yetAnotherShadeDesc.Texture2D.MipLevels = 5;
theDevice->CreateShaderResourceView(renderTexture, &yetAnotherShadeDesc, &QuadSeed.pOtherShaderResource);
theDevice->CreateShaderResourceView(postTexture, &yetAnotherShadeDesc, &PostQuad.pOtherShaderResource);
PostQuad.Initialize();
QuadSeed.Initialize(nullptr);
Translate(QuadSeed.worldMatrix, 0.0f, 0.0f, 3.0f);
D3D11_BUFFER_DESC viewPortsDesc;
ZeroMemory(&viewPortsDesc, sizeof(viewPortsDesc));
viewPortsDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
viewPortsDesc.ByteWidth = sizeof(D3D11_VIEWPORT) * 2;
viewPortsDesc.Usage = D3D11_USAGE_DYNAMIC;
viewPortsDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
//D3D11_SUBRESOURCE_DATA viewPortsSub;
//ZeroMemory(&viewPortsSub, sizeof(viewPortsSub));
#pragma region THE_LIGHTS
theLight = DIR_LIGHT(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -1.0f, 1.0f);
ambientLight[0] = 0.5f;
ambientLight[1] = 0.5f;
ambientLight[2] = 0.5f;
ambientLight[3] = 1.0f;
D3D11_BUFFER_DESC lightDesc;
ZeroMemory(&lightDesc, sizeof(lightDesc));
lightDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
lightDesc.ByteWidth = sizeof(theLight);
lightDesc.Usage = D3D11_USAGE_DYNAMIC;
lightDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
D3D11_SUBRESOURCE_DATA lightSub;
ZeroMemory(&lightSub, sizeof(lightSub));
lightSub.pSysMem = &theLight;
lightSub.SysMemPitch = 0;
lightSub.SysMemSlicePitch = 0;
theDevice->CreateBuffer(&lightDesc, &lightSub, &lightBuff);
D3D11_BUFFER_DESC ambDesc;
ZeroMemory(&ambDesc, sizeof(ambDesc));
ambDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
ambDesc.ByteWidth = 32;//sizeof(theLight);
ambDesc.Usage = D3D11_USAGE_DYNAMIC;
ambDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
D3D11_SUBRESOURCE_DATA ambSub;
ZeroMemory(&ambSub, sizeof(ambSub));
ambSub.pSysMem = &ambientLight;
ambSub.SysMemPitch = 0;
ambSub.SysMemSlicePitch = 0;
theDevice->CreateBuffer(&ambDesc, &ambSub, &ambientBuff);
thePtLight = DIR_LIGHT(0.0f, 0.0f, 1.0f, 1.0f, 0.5f, 0.0f, 0.5f);
D3D11_BUFFER_DESC ptDesc;
ZeroMemory(&ptDesc, sizeof(ptDesc));
ptDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
ptDesc.ByteWidth = sizeof(thePtLight);
ptDesc.Usage = D3D11_USAGE_DYNAMIC;
ptDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
D3D11_SUBRESOURCE_DATA ptSub;
ZeroMemory(&ptSub, sizeof(ptSub));
ptSub.pSysMem = &thePtLight;
ptSub.SysMemPitch = 0;
ptSub.SysMemSlicePitch = 0;
theDevice->CreateBuffer(&ptDesc, &ptSub, &ptltBuff);
theSpotLight = SPOT_LIGHT(-0.5f, 5.0f, 2.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.99f);
D3D11_BUFFER_DESC spotDesc;
ZeroMemory(&spotDesc, sizeof(spotDesc));
spotDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
spotDesc.ByteWidth = sizeof(theSpotLight);
spotDesc.Usage = D3D11_USAGE_DYNAMIC;
spotDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
D3D11_SUBRESOURCE_DATA spotSub;
ZeroMemory(&spotSub, sizeof(spotSub));
spotSub.pSysMem = &theSpotLight;
theDevice->CreateBuffer(&spotDesc, &spotSub, &spotBuff);
#pragma endregion
#endif
#endif
#if 1
// Matrix setup
float XScale, YScale, Aspect, zFar, zNear;
Aspect = 1.0f;
YScale = 1.0f / tanf((45.0f * 3.14f) / 180.0f);
XScale = YScale * Aspect;
zNear = 0.1f;
zFar = 100.0f;
projMatrix =
{
XScale, 0.0f, 0.0f, 0.0f,
0.0f, YScale, 0.0f, 0.0f,
0.0f, 0.0f, zFar / (zFar - zNear), 1.0f,
0.0f, 0.0f, -(zFar * zNear) / (zFar - zNear), 0.0f
};
cameraMatrix = Inverse4x4(viewMatrix);
SkyBox.worldMatrix.M[3][0] = viewMatrix.M[3][0];
SkyBox.worldMatrix.M[3][1] = viewMatrix.M[3][1];
SkyBox.worldMatrix.M[3][2] = viewMatrix.M[3][2];
scene[0] = /*cameraMatrix*/ viewMatrix;
scene[1] = projMatrix;
// Build World Matrix Buffer
D3D11_BUFFER_DESC worldBuffDesc;
ZeroMemory(&worldBuffDesc, sizeof(worldBuffDesc));
worldBuffDesc.Usage = D3D11_USAGE_DYNAMIC;
worldBuffDesc.ByteWidth = sizeof(M_4x4);
worldBuffDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
worldBuffDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
D3D11_SUBRESOURCE_DATA worldSub;
worldSub.pSysMem = &worldMatrix;
worldSub.SysMemPitch = 0;
worldSub.SysMemSlicePitch = 0;
theDevice->CreateBuffer(&worldBuffDesc, &worldSub, &pWorldBuffer);
D3D11_BUFFER_DESC sceneBuffDesc;
ZeroMemory(&sceneBuffDesc, sizeof(sceneBuffDesc));
sceneBuffDesc.Usage = D3D11_USAGE_DYNAMIC;
sceneBuffDesc.ByteWidth = sizeof(M_4x4) * 2;
sceneBuffDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
sceneBuffDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
D3D11_SUBRESOURCE_DATA sceneSub;
sceneSub.pSysMem = scene;
sceneSub.SysMemPitch = 0;
sceneSub.SysMemSlicePitch = 0;
theDevice->CreateBuffer(&sceneBuffDesc, &sceneSub, &sceneMatrixBuffer);
#endif
#if 1 // Rasterstate
CD3D11_RASTERIZER_DESC rasterDesc = CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT());
rasterDesc.FrontCounterClockwise = TRUE;
rasterDesc.CullMode = D3D11_CULL_NONE;
rasterDesc.AntialiasedLineEnable = true;
rasterDesc.MultisampleEnable = true;
theDevice->CreateRasterizerState(&rasterDesc, &pRasterState);
CD3D11_RASTERIZER_DESC otherDesc = CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT());
otherDesc.FrontCounterClockwise = FALSE;
otherDesc.CullMode = D3D11_CULL_FRONT;
otherDesc.AntialiasedLineEnable = true;
//rasterDesc.MultisampleEnable = true;
theDevice->CreateRasterizerState(&otherDesc, &pOtherState);
#endif
}
//--------------------------------------------------------------------------------------
// 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;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
// Initialize sample variables
// m_nCurMeshIndex = CUBE_MESH;
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.AddHelpKey( FRM_FONT_KEY_0, "Toggle Help" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, "Increase Hg param " );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, "Decrease Hg param " );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, "Increase InscatteringMultiplier param" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_4, "Decrease InscatteringMultiplier param" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_5, "Increase MieMultiplier param" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_6, "Decrease MieMultiplier param" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_7, "Increase Turbitity param" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_8, "Decrease Turbitity param" );
// m_UserInterface.AddHelpKey( FRM_FONT_KEY_9, "Change Shader Hoffman/Preetham" );
// Create a new terrain height field and landscape
UINT32 nWidth, nHeight;
BYTE* pHeightMapData = LoadTGA( "heights.tga", &nWidth, &nHeight, 3 );
if( NULL == pHeightMapData )
return FALSE;
HeightField heightField;
heightField.createFromRGBImage ( pHeightMapData
, nWidth
, nHeight
, 2.0
, 40.0
);
delete [] pHeightMapData;
BYTE* pTextureData = LoadTGA( "terrain.tga", &nWidth, &nHeight, 4 );
if( NULL == pTextureData )
return FALSE;
UINT32 nNormalsWidth, nNormalsHeight;
BYTE* pNormalMapData = LoadTGA( "normals.tga", &nNormalsWidth, &nNormalsHeight, 4 );
if( NULL == pNormalMapData )
return FALSE;
m_terrain.create( heightField );
mover.SetPosition( FRMVECTOR3( -((float)m_terrain.getTotalWidth())/2.0f, -70.0f, -((float)m_terrain.getTotalHeight())/2.0f));
m_terrain.GenTerrainAndNormalTextures( pTextureData, nWidth, nHeight,
pNormalMapData, nNormalsWidth, nNormalsHeight);
delete [] pTextureData;
delete [] pNormalMapData;
////////////////
// 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, 6000.0f );
// m_matLightPersp = FrmMatrixPerspectiveFovRH( FRM_PI/4.0f, 1.0f, 5.0f, 20.0f );
// Initialize the viewport
#ifdef TEMP
glViewport( 0, 0, m_nWidth, m_nHeight );
#endif
// Setup the camera view matrix
FRMVECTOR3 vCameraPosition = FRMVECTOR3( 0.0f, 0.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 light look at and up vectors
m_vLightLookAt = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
m_vLightUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
// Initial state
D3D11_RASTERIZER_DESC rdesc = CD3D11_RASTERIZER_DESC(D3D11_DEFAULT);
rdesc.CullMode = D3D11_CULL_NONE; // No culling for the terrain
rdesc.FrontCounterClockwise = TRUE; // Change the winding direction to match GL
D3DDevice()->CreateRasterizerState(&rdesc, &m_RasterizerState);
D3DDeviceContext()->RSSetState(m_RasterizerState.Get());
return TRUE;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
// Initialize sample variables
m_nCurMeshIndex = CUBE_MESH;
m_vLightPosition = FRMVECTOR3( 0.0f, 4.0f, 0.0f );
// 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;
//hack in a title for first model
m_UserInterface.SetHeading("Cook Torrance");
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.AddHelpKey( FRM_FONT_KEY_0, "Toggle Help" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, "Next Model" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, "Next Shader" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, "Increase Material Glossinesss" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_4, "Decrease Material Glossinesss" );
// Load the meshes
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 camera view matrix
FRMVECTOR3 vCameraPosition = FRMVECTOR3( 0.0f, 0.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 light look at and up vectors
m_vLightLookAt = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
m_vLightUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
// Initial state
D3D11_RASTERIZER_DESC rdesc = CD3D11_RASTERIZER_DESC(D3D11_DEFAULT);
rdesc.FrontCounterClockwise = TRUE; // Change the winding direction to match GL
D3DDevice()->CreateRasterizerState(&rdesc, &m_RasterizerState);
D3DDeviceContext()->RSSetState(m_RasterizerState.Get());
return TRUE;
}
int CD3DFont::Init()
{
// Create vertex buffer for the letters
HRESULT hr;
// Prepare to create a bitmap
unsigned int* pBitmapBits;
BITMAPINFO bmi;
ZeroMemory(&bmi.bmiHeader, sizeof(BITMAPINFOHEADER));
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = (int)m_dwTexWidth;
bmi.bmiHeader.biHeight = -(int)m_dwTexHeight;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biCompression = BI_RGB;
bmi.bmiHeader.biBitCount = 32;
// Create a DC and a bitmap for the font
HDC hDC = CreateCompatibleDC(nullptr);
HBITMAP hbmBitmap = CreateDIBSection(hDC, &bmi, DIB_RGB_COLORS, (void**)&pBitmapBits, nullptr, 0);
SetMapMode(hDC, MM_TEXT);
// create a GDI font
HFONT hFont = CreateFont(24, 0, 0, 0, FW_NORMAL, FALSE,
FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS, PROOF_QUALITY,
VARIABLE_PITCH, _T("Tahoma"));
if (nullptr == hFont) return E_FAIL;
HGDIOBJ hOldbmBitmap = SelectObject(hDC, hbmBitmap);
HGDIOBJ hOldFont = SelectObject(hDC, hFont);
// Set text properties
SetTextColor(hDC, 0xFFFFFF);
SetBkColor(hDC, 0);
SetTextAlign(hDC, TA_TOP);
TEXTMETRICW tm;
GetTextMetricsW(hDC, &tm);
m_LineHeight = tm.tmHeight;
// Loop through all printable characters and output them to the bitmap
// Meanwhile, keep track of the corresponding tex coords for each character.
int x = 0, y = 0;
char str[2] = "\0";
for (int c = 0; c < 127 - 32; c++)
{
str[0] = c + 32;
SIZE size;
GetTextExtentPoint32A(hDC, str, 1, &size);
if ((int)(x + size.cx + 1) > m_dwTexWidth)
{
x = 0;
y += m_LineHeight;
}
ExtTextOutA(hDC, x + 1, y + 0, ETO_OPAQUE | ETO_CLIPPED, nullptr, str, 1, nullptr);
m_fTexCoords[c][0] = ((float)(x + 0)) / m_dwTexWidth;
m_fTexCoords[c][1] = ((float)(y + 0)) / m_dwTexHeight;
m_fTexCoords[c][2] = ((float)(x + 0 + size.cx)) / m_dwTexWidth;
m_fTexCoords[c][3] = ((float)(y + 0 + size.cy)) / m_dwTexHeight;
x += size.cx + 3; // 3 to work around annoying ij conflict (part of the j ends up with the i)
}
// Create a new texture for the font
// possible optimization: store the converted data in a buffer and fill the texture on creation.
// That way, we can use a static texture
ID3D11Texture2D* buftex;
D3D11_TEXTURE2D_DESC texdesc = CD3D11_TEXTURE2D_DESC(D3D::GetBaseBufferFormat(), m_dwTexWidth, m_dwTexHeight,
1, 1, D3D11_BIND_SHADER_RESOURCE, D3D11_USAGE_DYNAMIC,
D3D11_CPU_ACCESS_WRITE);
hr = device->CreateTexture2D(&texdesc, nullptr, &buftex);
if (FAILED(hr))
{
PanicAlert("Failed to create font texture");
return hr;
}
D3D::SetDebugObjectName(buftex, "texture of a CD3DFont object");
// Lock the surface and write the alpha values for the set pixels
D3D11_MAPPED_SUBRESOURCE texmap;
hr = context->Map(buftex, 0, D3D11_MAP_WRITE_DISCARD, 0, &texmap);
if (FAILED(hr)) PanicAlert("Failed to map a texture at %s %d\n", __FILE__, __LINE__);
for (y = 0; y < m_dwTexHeight; y++)
{
u32* pDst32 = (u32*)((u8*)texmap.pData + y * texmap.RowPitch);
for (x = 0; x < m_dwTexWidth; x++)
{
const u8 bAlpha = (pBitmapBits[m_dwTexWidth * y + x] & 0xff);
*pDst32++ = (((bAlpha << 4) | bAlpha) << 24) | 0xFFFFFF;
}
}
// Done updating texture, so clean up used objects
context->Unmap(buftex, 0);
hr = D3D::device->CreateShaderResourceView(buftex, nullptr, ToAddr(m_pTexture));
if (FAILED(hr)) PanicAlert("Failed to create shader resource view at %s %d\n", __FILE__, __LINE__);
SAFE_RELEASE(buftex);
SelectObject(hDC, hOldbmBitmap);
DeleteObject(hbmBitmap);
SelectObject(hDC, hOldFont);
DeleteObject(hFont);
// setup device objects for drawing
m_pshader = D3D::CompileAndCreatePixelShader(fontpixshader);
if (m_pshader == nullptr) PanicAlert("Failed to create pixel shader, %s %d\n", __FILE__, __LINE__);
D3D::SetDebugObjectName(m_pshader.get(), "pixel shader of a CD3DFont object");
D3DBlob vsbytecode;
D3D::CompileShader(DX11::D3D::ShaderType::Vertex, fontvertshader, vsbytecode);
if (vsbytecode.Data() == nullptr) PanicAlert("Failed to compile vertex shader, %s %d\n", __FILE__, __LINE__);
m_vshader = D3D::CreateVertexShaderFromByteCode(vsbytecode);
if (m_vshader.get() == nullptr) PanicAlert("Failed to create vertex shader, %s %d\n", __FILE__, __LINE__);
D3D::SetDebugObjectName(m_vshader.get(), "vertex shader of a CD3DFont object");
const D3D11_INPUT_ELEMENT_DESC desc[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 28, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
hr = D3D::device->CreateInputLayout(desc, 3, vsbytecode.Data(), vsbytecode.Size(), ToAddr(m_InputLayout));
if (FAILED(hr)) PanicAlert("Failed to create input layout, %s %d\n", __FILE__, __LINE__);
D3D11_BLEND_DESC blenddesc;
blenddesc.AlphaToCoverageEnable = FALSE;
blenddesc.IndependentBlendEnable = FALSE;
blenddesc.RenderTarget[0].BlendEnable = TRUE;
blenddesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
blenddesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blenddesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blenddesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blenddesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
blenddesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
blenddesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
hr = D3D::device->CreateBlendState(&blenddesc, ToAddr(m_blendstate));
CHECK(hr == S_OK, "Create font blend state");
D3D::SetDebugObjectName(m_blendstate.get(), "blend state of a CD3DFont object");
D3D11_RASTERIZER_DESC rastdesc = CD3D11_RASTERIZER_DESC(D3D11_FILL_SOLID, D3D11_CULL_NONE, false, 0, 0.f, 0.f, false, false, false, false);
hr = D3D::device->CreateRasterizerState(&rastdesc, ToAddr(m_raststate));
CHECK(hr == S_OK, "Create font rasterizer state");
D3D::SetDebugObjectName(m_raststate.get(), "rasterizer state of a CD3DFont object");
D3D11_BUFFER_DESC vbdesc = CD3D11_BUFFER_DESC(MAX_NUM_VERTICES*sizeof(FONT2DVERTEX), D3D11_BIND_VERTEX_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
if (FAILED(hr = device->CreateBuffer(&vbdesc, nullptr, ToAddr(m_pVB))))
{
PanicAlert("Failed to create font vertex buffer at %s, line %d\n", __FILE__, __LINE__);
return hr;
}
D3D::SetDebugObjectName(m_pVB.get(), "vertex buffer of a CD3DFont object");
return S_OK;
}
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;
}
bool InitD3D11GUIRendering( RENDERER_SETTINGS * settings )
{
ID3DBlob * pCode = NULL;
ID3DBlob * pErrors = NULL;
if (D3DCompile( defaultGUIPixelShader, strlen(defaultGUIPixelShader), NULL, NULL, NULL, "main", "ps_4_0", NULL, NULL, &pCode, &pErrors ) != S_OK)
{
printf("[Renderer] D3DCompile (PS) failed\n");
return false;
}
if (pDevice->CreatePixelShader( pCode->GetBufferPointer(), pCode->GetBufferSize(), NULL, &pGUIPixelShader ) != S_OK)
{
printf("[Renderer] CreatePixelShader failed\n");
return false;
}
if (D3DCompile( defaultGUIVertexShader, strlen(defaultGUIVertexShader), NULL, NULL, NULL, "main", "vs_4_0", NULL, NULL, &pCode, &pErrors ) != S_OK)
{
printf("[Renderer] D3DCompile (VS) failed\n");
return false;
}
if (pDevice->CreateVertexShader( pCode->GetBufferPointer(), pCode->GetBufferSize(), NULL, &pGUIVertexShader ) != S_OK)
{
printf("[Renderer] CreateVertexShader failed\n");
return false;
}
D3D11_BUFFER_DESC desc;
ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
desc.ByteWidth = sizeof(float) * 7 * GUIQUADVB_SIZE;
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
if (pDevice->CreateBuffer(&desc, NULL, &pGUIQuadVB) != S_OK)
{
printf("[Renderer] CreateBuffer (VB) failed\n");
return false;
}
static D3D11_INPUT_ELEMENT_DESC pGUIDesc[] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0 * sizeof(float), D3D11_INPUT_PER_VERTEX_DATA, 0},
{"COLOR" , 0, DXGI_FORMAT_R8G8B8A8_UNORM , 0, 3 * sizeof(float), D3D11_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT , 0, 4 * sizeof(float), D3D11_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 1, DXGI_FORMAT_R32_FLOAT , 0, 6 * sizeof(float), D3D11_INPUT_PER_VERTEX_DATA, 0},
};
if (pDevice->CreateInputLayout( pGUIDesc, 4, pCode->GetBufferPointer(), pCode->GetBufferSize(), &pGUIQuadLayout) != S_OK)
{
printf("[Renderer] CreateInputLayout failed\n");
return false;
}
D3D11_BUFFER_DESC cbDesc;
ZeroMemory( &cbDesc, sizeof(D3D11_BUFFER_DESC) );
cbDesc.ByteWidth = sizeof( float ) * 4 * 4 * 2;
cbDesc.Usage = D3D11_USAGE_DYNAMIC;
cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
MatrixOrthoOffCenterLH( pGUIMatrix, 0, nWidth, nHeight, 0, -1.0f, 1.0f );
D3D11_SUBRESOURCE_DATA subData;
ZeroMemory( &subData, sizeof(D3D11_SUBRESOURCE_DATA) );
subData.pSysMem = &pGUIMatrix;
if (pDevice->CreateBuffer( &cbDesc, &subData, &pGUIConstantBuffer ) != S_OK)
{
printf("[Renderer] CreateBuffer (CB) failed\n");
return false;
}
D3D11_BLEND_DESC blendDesc = CD3D11_BLEND_DESC( CD3D11_DEFAULT() );
blendDesc.RenderTarget[0].BlendEnable = true;
blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
if (pDevice->CreateBlendState( &blendDesc, &pGUIBlendState ) != S_OK)
return false;
D3D11_RASTERIZER_DESC rastDesc = CD3D11_RASTERIZER_DESC( CD3D11_DEFAULT() );
rastDesc.ScissorEnable = true;
if (pDevice->CreateRasterizerState( &rastDesc, &pGUIRasterizerState ) != S_OK)
return false;
return true;
}
